pine2pyne 0.2.4__py3-none-any.whl

pine2pyne/value_blocks.py

@@ -0,0 +1,357 @@
+"""Value blocks lowered the way PyneComp lowers them.
+
+A Pine ``if`` or ``switch`` used as a value (assigned, or ending a function body)
+becomes statements around one temporary, numbered in source order across the
+module (``__block_result__``, ``__block_result_1__``, ...)::
+
+    ma = switch mode              __block_result__ = na
+        "A" => ta.sma(close, 5)   __switch__ = mode
+        "B" => ta.ema(close, 5)   if __switch__ == 'A':
+                                      __block_result__ = ta.sma(close, 5)
+                                  elif __switch__ == 'B':
+                                      __block_result__ = ta.ema(close, 5)
+                                  ma = __block_result__
+
+A switch with a subject reads it once, into ``__switch__``; one nested ``n`` blocks
+deep in its function reads it into ``__switch_<n>__``. A switch statement does too. A branch whose value is itself an ``if`` or a
+``switch`` gets the next number and hands its value to the outer temporary. A
+function whose body ends with an ``if`` or a ``switch`` returns the temporary.
+Measured on ``assets/pyne``: 302 modules hold block results, 151 a ``__switch__``.
+"""
+from __future__ import annotations
+
+import dataclasses
+from typing import List, Optional
+
+from .ast_nodes import (
+    ArrayLiteral, Assignment, BinaryOp, ExpressionStatement, ForInLoop, ForLoop, FuncDecl, FunctionCall, Identifier,
+    IfExpression, IfStatement, Literal, NaLiteral, RawCode, Reassignment, Script, SwitchExpression, SwitchStatement,
+    TupleDestructure, VarDecl, VaripDecl, WhileLoop,
+)
+
+_VALUE_NODES = (IfExpression, SwitchExpression)
+_LOOPS = (ForLoop, ForInLoop, WhileLoop)
+#: what may give a value: an if/switch (statement or expression) or a loop (its last pass's last statement)
+_VALUE_GIVERS = (IfStatement, SwitchStatement, IfExpression, SwitchExpression) + _LOOPS
+
+
+def _laid_out(statement, origin):
+    """`statement` without a Pine line of its own printed as at the first line found in `origin`: the
+    blank lines around it follow that line (`source_line`, read by the code generator only)."""
+    if not statement.line:
+        from .ast_walk import walk
+        statement.source_line = next((found.line for found in walk(origin) if getattr(found, 'line', 0)), 0)
+    return statement
+
+
+def _is_bare_value(statement) -> bool:
+    """A statement that only names a value (`x`, `na`, `false`): it does nothing in a block."""
+    if not isinstance(statement, ExpressionStatement):
+        return False
+    expr = statement.expr
+    if isinstance(expr, FunctionCall) and expr.func in _CASTS and len(expr.args) == 1 and not expr.kwargs:
+        expr = expr.args[0]  # `int(na)` too (PyneComp)
+    return isinstance(expr, (Identifier, NaLiteral, Literal))
+
+
+_CASTS = frozenset({'int', 'float', 'bool', 'string', 'color'})
+
+
+def _without_bare_values(statements: list) -> list:
+    """A loop's or a branch's statements without bare values; `pass` when nothing is left."""
+    kept = [statement for statement in statements if not _is_bare_value(statement)]
+    if kept or not statements:
+        return kept
+    return [RawCode(code='pass', line=getattr(statements[0], 'line', 0))]
+
+
+def _discarding_last_declaration(statements):
+    """A statement block (an ``if``, ``switch`` or loop not used as a value) whose last statement
+    declares a variable: PyneComp keeps only the declared value, an expression statement, as a
+    block's last statement is its (here unused) value. ``float x = na`` keeps ``na(float)``."""
+    if not statements:
+        return statements
+    last = statements[-1]
+    if isinstance(last, (VarDecl, VaripDecl)) or (isinstance(last, Assignment)
+                                                  and isinstance(last.target, (str, TupleDestructure))):
+        value = last.value
+        if isinstance(value, _VALUE_NODES):
+            return statements
+        if isinstance(value, NaLiteral) and getattr(last, 'type_hint', None):
+            value = FunctionCall(func=NaLiteral(), args=[Identifier(name=last.type_hint)],
+                                 line=last.line, column=last.column)
+        return statements[:-1] + [ExpressionStatement(expr=value, line=last.line, column=last.column)]
+    return statements
+
+
+def _statement_block(statements):
+    return _discarding_last_declaration(_without_bare_values(statements))
+
+
+#: user function name -> how many values its result has (0: not a tuple); set per script
+_FUNCTION_WIDTHS: dict = {}
+
+
+def _tuple_width(node) -> int:
+    """How many values an if/switch value yields: a tuple branch `[a, b]` gives 2, as does a call
+    of a user function whose value is a 2-tuple; else 0."""
+    if isinstance(node, ArrayLiteral):
+        return len(node.elements)
+    if isinstance(node, FunctionCall) and isinstance(node.func, str):
+        return _FUNCTION_WIDTHS.get(node.func, 0)
+    if isinstance(node, list):
+        return _tuple_width(node[-1]) if node else 0
+    if isinstance(node, ExpressionStatement):
+        return _tuple_width(node.expr)
+    if isinstance(node, IfExpression):
+        return max(_tuple_width(node.true_expr), _tuple_width(node.false_expr) if node.false_expr is not None else 0)
+    if isinstance(node, IfStatement):
+        branches = [node.body] + [body for _, body in node.elseifs] + ([node.else_body] if node.else_body else [])
+        return max(_tuple_width(branch) for branch in branches)
+    if isinstance(node, (SwitchExpression, SwitchStatement)):
+        branches = [body for _, body in node.cases] + ([node.default] if node.default is not None else [])
+        return max((_tuple_width(branch) for branch in branches), default=0)
+    if isinstance(node, _LOOPS):
+        return _tuple_width(node.body)
+    return 0
+
+
+def _function_widths(script: Script) -> dict:
+    """The tuple width of every user function's value, followed through calls of other functions."""
+    functions = [node for node in list(script.declarations) + list(script.body) if isinstance(node, FuncDecl)]
+    _FUNCTION_WIDTHS.clear()
+    for _ in range(len(functions) + 1):
+        changed = False
+        for function in functions:
+            width = _tuple_width(function.body if isinstance(function.body, list) else [function.body])
+            if width and _FUNCTION_WIDTHS.get(function.name) != width:
+                _FUNCTION_WIDTHS[function.name] = width
+                changed = True
+        if not changed:
+            break
+    return dict(_FUNCTION_WIDTHS)
+
+
+class _Names:
+    """``__<stem>__``, then ``__<stem>_1__``, ``__<stem>_2__``, ... per stem."""
+
+    def __init__(self) -> None:
+        self._counts: dict = {}
+
+    def next(self, stem: str) -> str:
+        count = self._counts.get(stem, 0)
+        self._counts[stem] = count + 1
+        return f'__{stem}__' if count == 0 else f'__{stem}_{count}__'
+
+
+class _Lowering:
+    def __init__(self, version: int = 6) -> None:
+        self.version = version
+        self.names = _Names()
+        # how deep the statement being lowered is nested in blocks of its function (main() or a user
+        # function): PyneComp names a switch subject by it, `__switch__` at 0, `__switch_<depth>__` below
+        self.depth = 0
+
+    def switch_subject(self) -> str:
+        return '__switch__' if self.depth == 0 else f'__switch_{self.depth}__'
+
+    # ------------------------------------------------------------ statements
+
+    def nested(self, statements, lower):
+        """`lower(statements)` one block deeper."""
+        self.depth += 1
+        try:
+            return lower(statements)
+        finally:
+            self.depth -= 1
+
+    def block(self, statements) -> list:
+        if statements is None:
+            return None
+        lowered: List = []
+        for statement in statements:
+            lowered.extend(self.statement(statement))
+        return lowered
+
+    def statement(self, node) -> list:
+        replace = dataclasses.replace
+        if isinstance(node, (Assignment, Reassignment, VarDecl, VaripDecl)) \
+                and isinstance(node.value, _VALUE_NODES + _LOOPS):
+            target = getattr(node, 'target', None)
+            width = len(target.names) if isinstance(target, TupleDestructure) else _tuple_width(node.value)
+            result = self.names.next('block_result')
+            value = node.value
+            if isinstance(value, ForLoop):
+                value = dataclasses.replace(value, is_assigned_value=True)
+            statements = [self._initial(result, width, node.line)] + self.value(value, result)
+            statements.append(replace(node, value=Identifier(name=result)))
+            return statements
+        if isinstance(node, SwitchStatement):
+            return self.switch(node, None)
+        if isinstance(node, IfStatement):
+            return [replace(node, body=_statement_block(self.nested(node.body, self.block)),
+                            elseifs=[(condition, _statement_block(self.nested(body, self.block)))
+                                     for condition, body in node.elseifs],
+                            else_body=_statement_block(self.nested(node.else_body, self.block))
+                            if node.else_body is not None else None)]
+        if isinstance(node, (ForLoop, ForInLoop, WhileLoop)):
+            return [replace(node, body=_statement_block(self.nested(node.body, self.block)))]
+        if isinstance(node, FuncDecl):
+            return [self.function(node)]
+        return [node]
+
+    def function(self, node: FuncDecl) -> FuncDecl:
+        saved, self.depth = self.depth, 0  # a function's body is the top of its own blocks
+        try:
+            lowered = self._function(node)
+        finally:
+            self.depth = saved
+        original = node.body[-1] if isinstance(node.body, list) and node.body else node.body
+        returns_if_value = isinstance(getattr(original, 'value', None), IfExpression) and isinstance(
+            original, (Assignment, VarDecl, VaripDecl))
+        if (self.version >= 6 or returns_if_value) and isinstance(lowered.body, list) and lowered.body:
+            # Pine v6: a function ending with a declaration returns the declared value itself
+            # (probe tmp/probes/tail6.pine); v5 keeps the declaration and returns its name, but for an
+            # if value, whose block result it returns (tail5b.pine: not for a switch value)
+            last = lowered.body[-1]
+            declares = isinstance(last, (VarDecl, VaripDecl)) or (
+                isinstance(last, Assignment) and isinstance(last.target, (str, TupleDestructure)))
+            if declares and last.value is not None and not isinstance(last.value, _VALUE_NODES + _LOOPS):
+                tail = ExpressionStatement(expr=last.value, line=last.line, column=last.column)
+                lowered = dataclasses.replace(lowered, body=lowered.body[:-1] + [tail])
+        return lowered
+
+    def _function(self, node: FuncDecl) -> FuncDecl:
+        body = node.body
+        if isinstance(body, _VALUE_NODES):
+            body = [ExpressionStatement(expr=body, line=node.line)]
+        elif isinstance(body, (Assignment, Reassignment, VarDecl, VaripDecl)):
+            body = [body]  # a one-line body that declares: `f(x) => float r = x + 1`
+            node = dataclasses.replace(node, body=body)
+        if not isinstance(body, list) or not body:
+            return node
+        last = body[-1]
+        if isinstance(last, ExpressionStatement) and isinstance(last.expr, _VALUE_NODES):
+            last = last.expr
+        if not isinstance(last, _VALUE_GIVERS):
+            return dataclasses.replace(node, body=self.block(body))
+        lowered = self.block(body[:-1])
+        result = self.names.next('block_result')
+        lowered.append(self._initial(result, _tuple_width(last), getattr(body[-1], 'line', 0)))
+        lowered.extend(self.value(last, result))
+        lowered.append(ExpressionStatement(expr=Identifier(name=result)))  # the function's value
+        return dataclasses.replace(node, body=lowered)
+
+    # ------------------------------------------------------------ values
+
+    @staticmethod
+    def _initial(result: str, width: int, line: int) -> Assignment:
+        value = ArrayLiteral(elements=[NaLiteral() for _ in range(width)]) if width else NaLiteral()
+        return Assignment(target=result, value=value, line=line)
+
+    def value(self, node, result: str) -> list:
+        """Statements that leave the value of an if/switch (expression or statement) in `result`."""
+        if isinstance(node, (SwitchExpression, SwitchStatement)):
+            return self.switch(node, result)
+        if isinstance(node, _LOOPS):
+            # the loop's value is its last pass's: each pass assigns its last statement's value
+            return [dataclasses.replace(node, body=self.nested(node.body, lambda body: self.branch(body, result)))]
+        def arm(body):
+            return self.nested(body, lambda statements: self.branch(statements, result))
+        if isinstance(node, IfExpression):
+            # an `else if` chain is one if/elif with one block result (probe nb3_05); its blocks are numbered
+            # in source order, the first arm's first (TFlab/AlertSenderLibrary)
+            first = arm(node.true_expr)
+            elseifs, rest = [], node.false_expr
+            while isinstance(rest, IfExpression) and rest.chained:  # `else if`; an `if` inside an `else` block stays
+                chained = rest
+                elseifs.append((chained.condition, arm(chained.true_expr)))
+                rest = chained.false_expr
+            return [_laid_out(IfStatement(condition=node.condition, body=first, elseifs=elseifs,
+                                          else_body=arm(rest) if rest is not None else None,
+                                          line=node.line), node)]
+        return [dataclasses.replace(
+            node, body=arm(node.body),
+            elseifs=[(condition, arm(body)) for condition, body in node.elseifs],
+            else_body=arm(node.else_body) if node.else_body is not None else None)]
+
+    def switch(self, node, result: Optional[str]) -> list:
+        lowered: List = []
+        conditions = [case for case, _ in node.cases]
+        if node.expr is not None:
+            subject = self.switch_subject()
+            lowered.append(_laid_out(Assignment(target=subject, value=node.expr, line=node.line), node))
+            conditions = [BinaryOp(left=Identifier(name=subject), op='==', right=case) for case in conditions]
+        bodies = [body for _, body in node.cases]
+        if result is None:
+            arms = [_discarding_last_declaration(self.nested(body, self.block)) for body in bodies]
+            default = _discarding_last_declaration(self.nested(node.default, self.block))
+        else:
+            arms = [self.nested(body, lambda statements: self.branch(statements, result)) for body in bodies]
+            default = (self.nested(node.default, lambda statements: self.branch(statements, result))
+                       if node.default is not None else None)
+        if not arms:
+            return lowered + (default or [])
+        lowered.append(_laid_out(IfStatement(condition=conditions[0], body=arms[0],
+                                             elseifs=list(zip(conditions[1:], arms[1:])), else_body=default,
+                                             line=node.line), node))
+        return lowered
+
+    def branch(self, body, result: str) -> list:
+        """A branch's statements, its last one's value assigned to `result`."""
+        if not isinstance(body, list):
+            body = [ExpressionStatement(expr=body)]
+        if not body:
+            return body
+        lowered = self.block(body[:-1])
+        last = body[-1]
+        nested = last.expr if isinstance(last, ExpressionStatement) and isinstance(last.expr, _VALUE_NODES) else last
+        if isinstance(nested, _VALUE_GIVERS):
+            inner = self.names.next('block_result')
+            lowered.append(self._initial(inner, _tuple_width(nested), getattr(last, 'line', 0)))
+            lowered.extend(self.value(nested, inner))
+            lowered.append(Reassignment(target=result, value=Identifier(name=inner)))
+        elif isinstance(last, ExpressionStatement):
+            lowered.append(Reassignment(target=result, value=last.expr, line=last.line))
+        else:
+            lowered.extend(self.statement(last))
+            target = getattr(last, 'target', None)
+            if isinstance(target, str):
+                lowered.append(Reassignment(target=result, value=Identifier(name=target)))
+        return lowered
+
+
+def lower_value_blocks(script: Script) -> Script:
+    """`script` with every if/switch value lowered to statements, PyneComp's way."""
+    version_text = getattr(script.version, 'version', '') if script.version else ''
+    lowering = _Lowering(int(version_text) if str(version_text).isdigit() else 6)
+    _function_widths(script)
+    items = sorted([(item.line, 0, index, item) for index, item in enumerate(script.declarations)]
+                   + [(item.line, 1, index, item) for index, item in enumerate(script.body)],
+                   key=lambda entry: (entry[0], entry[1], entry[2]))
+    declarations = list(script.declarations)
+    lowered_vars: list = []
+    body_parts = {index: [item] for index, item in enumerate(script.body)}
+    for _, kind, index, item in items:
+        if kind == 0:
+            if isinstance(item, FuncDecl):
+                declarations[index] = lowering.function(item)
+            elif isinstance(item, (VarDecl, VaripDecl)) and isinstance(item.value, _VALUE_NODES + _LOOPS):
+                # the lowered statements run in main(): they move to the body, at the var's line
+                parts = lowering.statement(item)
+                for part in parts:
+                    if not getattr(part, 'line', 0):
+                        part.line = item.line
+                declarations[index] = None
+                lowered_vars.append((item.line, parts))
+        else:
+            parts = lowering.statement(item)
+            for part in parts:  # the transformer orders the top level by Pine line
+                if not getattr(part, 'line', 0):
+                    part.line = item.line
+            body_parts[index] = parts
+    body = [statement for index in range(len(script.body)) for statement in body_parts[index]]
+    for _, parts in lowered_vars:
+        body.extend(parts)  # the transformer orders the top level by line
+    declarations = [item for item in declarations if item is not None]
+    return dataclasses.replace(script, declarations=declarations, body=body)

pine2pyne-0.2.4.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: pine2pyne
+Version: 0.2.4
+Summary: Pine Script v6 to PyneCore Python transpiler
+Author: rubycell
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/pine2pyne/pine2pyne
+Project-URL: Repository, https://github.com/pine2pyne/pine2pyne
+Keywords: pinescript,tradingview,transpiler,pynecore,backtesting
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dishka>=1.4
+Provides-Extra: runtime
+Requires-Dist: opencode-pyneruntime[cli]>=6.9.1; extra == "runtime"
+Dynamic: license-file
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/pine2pyne/.github/main/images/logo.png" height="115px" alt="pine2pyne" />
+</p>
+
+<p align="center">
+  <strong>TradingView Pine Script, transpiled to Python on your own machine</strong><br>
+  Indicators, strategies and libraries in Pine Script v4, v5 and v6, compiled to PyneCore.<br>
+  No API key, no quota, no network.
+</p>
+
+> pine2pyne converts TradingView Pine Script indicators, strategies and libraries into Python scripts
+for [PyneCore](https://pynecore.org), the open-source runtime that runs Pine-style code bar by bar.
+A converted script can backtest offline on any candles you have, without a TradingView account or
+chart.
+
+## Install
+
+Requires Python 3.11+.
+
+```bash
+pip install pine2pyne
+```
+
+This installs the `pine2pyne` command. `python -m pine2pyne` does the same.
+
+## Usage
+
+```bash
+pine2pyne strategy.pine -o strategy.py
+```
+
+```
+pine2pyne [-h] [-o OUTPUT] [--validate] [-v] [--version] input [input ...]
+```
+
+| Option | Meaning |
+|---|---|
+| `input` | One or more `.pine` files. A quoted pattern such as `"src/*.pine"` is expanded by pine2pyne itself |
+| `-o`, `--output` | Output file, or a directory for several inputs. Without it, the code goes to stdout |
+| `--validate` | Check the script, write nothing |
+| `-v`, `--verbose` | Print each step |
+| `--version` | Print the version and exit |
+
+## Examples
+
+| Command | Result |
+|---|---|
+| `pine2pyne a.pine` | The code on stdout, so `pine2pyne a.pine > a.py` gives a clean file |
+| `pine2pyne a.pine -o out/a.py` | Written to `out/a.py`. Missing directories are created |
+| `pine2pyne a.pine b.pine -o out/` | `out/a.py` and `out/b.py` |
+| `pine2pyne "src/*.pine" -o out/` | One `<name>.py` in `out/` for every match of the pattern |
+| `pine2pyne a.pine --validate` | `✓ a.pine - Valid syntax`, or the error |
+
+With several inputs, `-o` is a directory. A failed file does not stop the batch: every input is
+processed, then a summary is printed:
+
+```
+Summary: 41 succeeded, 2 failed
+```
+
+## Errors
+
+Errors and warnings go to stderr with the Pine line and column:
+
+```
+✗ bad.pine: Error at 4:6: Pine refuses: cannot assign with ':=' to a history reference (x[n]) [history-target]
+```
+
+A warning (`⚠`) does not stop the file from being written.
+
+| Exit code | When |
+|---|---|
+| `0` | Every input was converted or validated |
+| `1` | At least one input failed, or no input file was found |
+
+## License
+
+Apache-2.0, see [LICENSE](https://github.com/pine2pyne/pine2pyne/blob/main/LICENSE).

pine2pyne-0.2.4.dist-info/RECORD

@@ -0,0 +1,75 @@
+pine2pyne/__init__.py,sha256=SzwH5GzUz3MGhzC6YY-aHrCjT47kKEuI_CqFTdahZCI,2352
+pine2pyne/__main__.py,sha256=w6UY1yZijkjI0YRgq03guOunEYTp9S4DjwsAips2GOk,228
+pine2pyne/ast_nodes.py,sha256=4jFE1sXocScgshlBtAmOYMU_Et25JmLhA13Vr7QG9M8,13066
+pine2pyne/ast_walk.py,sha256=Qt0HUyF7nR3G9kErTB22TuarUJ0g4xQV8QBQ3YeuuIg,4037
+pine2pyne/block_value_lowering.py,sha256=gAtc0tX0tBfpqrMwIRhbXOUP5q8F60WHR-5Xjj0SjUE,35086
+pine2pyne/bool_builtins.py,sha256=VSJqSKn06bPNBHm00LDcurzr24ff7lyGr3SrFbGR0XA,1921
+pine2pyne/bool_value_typing.py,sha256=oR4bVYRQD-zJVWnxRSVStnR8ZeRpVqpJKwWCp71uS9c,29274
+pine2pyne/cli.py,sha256=OBEbgDEEUh-kR8J5bUVIQA1XAo_KDYDUgLSzLctrfFY,8519
+pine2pyne/codegen.py,sha256=3uAbxOkres6A_GRh0X7OgenQ3eFBBipqQCwBrxCp4Ns,39412
+pine2pyne/condition_typing.py,sha256=absbpo0fm-ZOzehZzJGvCFPMaY0T15HdMSBgI9ZPLdw,14469
+pine2pyne/conditional_history_calls.py,sha256=T2BIN0MpPxLc17nj1VIynHsM2i4l_jd9dTol4Nb0V-E,4556
+pine2pyne/di.py,sha256=0xikVhk_1HplqMBCZkEr0eDwG76d__wXSwZZC5yw4Rg,5347
+pine2pyne/emitted_names.py,sha256=vB5-d-2ChM7Bvp_VdrSseEX3ElGEH4Hz2krWlPbxreI,7168
+pine2pyne/errors.py,sha256=6T2OoC0u2inr1XWMIeC3glI6aplL8dcgET7maA4jDjY,2622
+pine2pyne/for_loop_end_bound.py,sha256=n5RO0yzkGJyckDbbMQoxs9T99QE4UUHjM--lEY4U10o,9813
+pine2pyne/grouped_history_lowering.py,sha256=hxoQcJy0HyvzA7jXQLkcYeJUJ0onDJgKs3Jm5auf5FM,16963
+pine2pyne/import_resolver.py,sha256=2x32cs22REpPc912u8r4mZDNtRPftnZ1Vzq844leU5s,23400
+pine2pyne/input_hoisting.py,sha256=YXCpV_4r7Cf3CJMP66Yh3LbSaXL4SRddyAObkQcA4CM,10020
+pine2pyne/legacy_function_names.py,sha256=4vnHEJsmYbO7kMh2aXgh4OcogsAdOa_Q6Rruxnxh-4s,3772
+pine2pyne/legacy_sessions.py,sha256=AOu_y1iyzpZcfjkJo8Orny68acVcZDBVLovwdExzMGU,3286
+pine2pyne/lexer.py,sha256=LwgFH26MXksgb5FK5RVXwVK6iyAeNLnGqFAQuaNJNiw,26210
+pine2pyne/library_collision.py,sha256=lQO68h0XOuQ3y3UAGjJCAqQgCQgvJvC_BePueHlDQA8,22407
+pine2pyne/namespace_members.py,sha256=CO-oAesSy6LWthD2qItUrL3cTm8ZZ2Yulg3q_mD69BA,12859
+pine2pyne/node_ids.py,sha256=hu2VVtbRKPSaS1K2Nm5qeeG_0reGY5E_lSon9HbHX_k,10500
+pine2pyne/once_lowering.py,sha256=frr0g9nX612MKsPiLyeFEDvyoRcQDQTsBiUZ-qMUiq8,3481
+pine2pyne/overload_resolution.py,sha256=zWA2jbJ-RgnSUuNYoS0GmYwqygW4avPwYa4yfDDYevE,24635
+pine2pyne/parse_repair.py,sha256=Uec959EDCvnqeHdVD1ZpSizH150rUAk55BnYF9EbNBM,18882
+pine2pyne/parser.py,sha256=Tq8BYIaFEewXHRp08jU0ZO9qFDcBsp-ssoynOCHhqcM,81678
+pine2pyne/pine_builtins.py,sha256=dI7plYXbyho1Wsz7lWBjjYlQhdtwXCE5QTkG90kpHsI,17703
+pine2pyne/pine_semantics.py,sha256=e0CSoUCFp6BYzb2XNIi5_cQVgHfm--lMTKGvaTuraJw,34765
+pine2pyne/scope_renamer.py,sha256=GN9myfB5tBPKflPoPsCw6JqH7toqhj804AoBAO4hzIg,57178
+pine2pyne/strategy_when_lowering.py,sha256=bN5rAEKGy6bkp3Rm093GnAfpwtswExYsBbBGOdMeMbo,5334
+pine2pyne/strict_boolean.py,sha256=7Z-q2tdVk0rFgu4SecX9GVaWgBof_IFtBKjw1tBolB0,5471
+pine2pyne/symbol_table.py,sha256=SO40do-faSu-n29-5GOrkKAqEK6Ef9BGtw4sC0w9Jbo,6146
+pine2pyne/tokens.py,sha256=diG6z5_9DsDCdSN-sapdDAbdIwvklQPuC-05tkhQzDk,3792
+pine2pyne/transformer.py,sha256=Qpzeahx8wYntviybWPlE1Fq0CaV1uRrE7_tadRivFyo,138650
+pine2pyne/type_inference.py,sha256=8_ElqzbCefS_lvLBzgue7_gMU3jQBWGkT6Tz3K5LB34,20317
+pine2pyne/udt_field_defaults.py,sha256=OV2lnodQo7m_5dh7UFp2E7OcT8DQuMCe4xcTQGmReng,8231
+pine2pyne/value_blocks.py,sha256=6uR5Jy6329S1j8NpvGqTM6ntUq6BCsamURomiMA3PSQ,18528
+pine2pyne/compat/__init__.py,sha256=NPkw4Hs_p7-oXO4utBMpLzRtCr3VTNzsiSo8jgzITwM,536
+pine2pyne/compat/__main__.py,sha256=5zfJK8Dgm9BJ69PSo2ZGGVk-DPdq3Ihw9qpncugs6Hg,83
+pine2pyne/compat/cli.py,sha256=jEnPPqk_PzQ5QP1XxBkigy00T9qCRUENRVnGyHhrA7Q,4625
+pine2pyne/compat/comparison.py,sha256=00zi4ycrCmubVu4_Y9kZG6ah69e_V0b6XnIh22w90mY,4097
+pine2pyne/compat/corpus.py,sha256=E_FMkYo5hmRJDw-vmD0AGa565V1AxPNLhQR16C5YnmU,2363
+pine2pyne/compat/report.py,sha256=W1JHMJycVkCI_6lsoTaoOXJ9XjTv_biKPQZ-pMbw3ls,4446
+pine2pyne/compat/runner.py,sha256=Glq1rt_ypxdnt3s95d-juVyMMZXsDDkO7_DGPfhmsBA,2416
+pine2pyne/core/__init__.py,sha256=3QUg8SctseD0BtJRp472aUOBULjBnY5fZLTkBL1cKRQ,527
+pine2pyne/core/contracts.py,sha256=_UD56mxszLlotsddvVihkr8KoIMidjagMbziOljCh9s,3974
+pine2pyne/emit/__init__.py,sha256=y7RXTwj9ynChimkymw4vq9hx6EMFqjm4ovKKvmSt1HQ,257
+pine2pyne/emit/legacy.py,sha256=JSYMd40prbGZZ-TUoR2QsywRcjmMF2WUWBvuxNCGXrE,454
+pine2pyne/emit/pynecomp/__init__.py,sha256=Wiu9RniZKeeLbAKle-4-eU52iiYw9mwyKtuquf0UbCU,711
+pine2pyne/emit/pynecomp/banner.py,sha256=9JjQ7uKgfR9fXC-lqHqJQ2PgTi44Q8n8_wD4qM2avk8,902
+pine2pyne/emit/pynecomp/blank_lines.py,sha256=lArRBwTxhgHixAQ_bTtW-_QX_J4lc4sgCIzf6fDM-RQ,3297
+pine2pyne/emit/pynecomp/emitter.py,sha256=7uohVRtp11w0igx60Usq_IrN3pHD6T6knvPOZUZNS3Q,2657
+pine2pyne/emit/pynecomp/imports.py,sha256=M2SCp4VinQKW-AVEaVS7e0_3nzWQGGwfqfw6h8-XF6A,2858
+pine2pyne/emit/pynecomp/printer.py,sha256=Ff-8RP9_RlT6xwFjgzJy09tj8uKpUrue_KM2ln0_fa8,14661
+pine2pyne/emit/pynecomp/unparser.py,sha256=I7A8f4PR6fAa6g4rz1l7imvwPfevV-biz6wtwoW0l_k,9256
+pine2pyne/emit/pynecomp/passes/__init__.py,sha256=y5UO5oSL3jSXkg3wvpH71hK_DD6bCQee72iIVIyS57U,2378
+pine2pyne/emit/pynecomp/passes/annotations.py,sha256=QnHM8LK2ZANqXpiU1-ZtbglaSDJ6A1M_q4gk9j0rayk,23309
+pine2pyne/emit/pynecomp/passes/base.py,sha256=WtfImL0bxhDAqt4JtnbofWGpvGTnbRUKTN56lxb6ANA,2501
+pine2pyne/emit/pynecomp/passes/builtins.py,sha256=vrHnWW8Dq0qwl_hrYGbX81OIyYLn_B92MaXMxdg3CQo,7891
+pine2pyne/emit/pynecomp/passes/hoisting.py,sha256=glfVQT3SLqJOaFy8cIJFSS3eFEV62TIX2Ax-kMZHats,9827
+pine2pyne/emit/pynecomp/passes/imports.py,sha256=Wm-NGUh6ALJiSufHeVZfhO5Z4oqZGfJParl48pETzxE,6079
+pine2pyne/emit/pynecomp/passes/legacy_colors.py,sha256=cOIeIhPQHAFBUycL11UaoZUzDp-mLxfw65cD2pY4gKU,5240
+pine2pyne/emit/pynecomp/passes/library.py,sha256=K41iVWyV9Thelwo9KSECl765qo70NpJm9FMXk2QO4QA,11405
+pine2pyne/emit/pynecomp/passes/rewrites.py,sha256=tDWAVHCSh1cKoaUMiR5HAQjHqJK3ItrM65QZNTqHCw0,10186
+pine2pyne/pipeline/__init__.py,sha256=FB-erFlezSyRIsFphjHZJklZ6CDAcEN9GU7v_dBKguw,462
+pine2pyne/pipeline/service.py,sha256=6iJjpSDgY1GIPJMmP33oDw9UGwr4wCXzeGKzMw1VTq4,2216
+pine2pyne/pipeline/stages.py,sha256=woUABTKnqX57i9Om_o4E2_-UHEpFec8E-uVyTXsT06E,2491
+pine2pyne-0.2.4.dist-info/licenses/LICENSE,sha256=l6ZEJ0BCsllGRX5Pg-ygs6mQD03fLXJggIyKnSMwC8E,11342
+pine2pyne-0.2.4.dist-info/METADATA,sha256=RrQS_llKCO62x5EiHZHXfXfoRC9_prUnJutVjrAYryw,3319
+pine2pyne-0.2.4.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+pine2pyne-0.2.4.dist-info/entry_points.txt,sha256=RfEHcGj3OVRyq7G-igSZAhR7ff7QZFBzUVWtPIo4Yjw,94
+pine2pyne-0.2.4.dist-info/top_level.txt,sha256=ge_qvuxsfM_9zOv_hIwyLCMe1S8RAr5nUR6n3aBO6J0,10
+pine2pyne-0.2.4.dist-info/RECORD,,

pine2pyne-0.2.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pine2pyne-0.2.4.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pine2pyne = pine2pyne.cli:main
+pine2pyne-compat = pine2pyne.compat.cli:main