pine2pyne 0.2.4__py3-none-any.whl

pine2pyne/namespace_members.py

@@ -0,0 +1,247 @@
+"""
+The members of each pynecore.lib namespace, as the runtime defines them.
+
+GENERATED by tools/collect_namespace_members.py from opencode-pyneruntime 6.9.4; do not
+edit by hand. A binding named like a namespace uses it to tell `N.m` on the
+binding from `N.m` on the namespace (card #9).
+"""
+from typing import Dict, FrozenSet
+
+NAMESPACE_MEMBERS: Dict[str, FrozenSet[str]] = {
+    'adjustment': frozenset({
+        'dividends', 'none', 'splits',
+    }),
+    'alert': frozenset({
+        'alert', 'freq_all', 'freq_once_per_bar', 'freq_once_per_bar_close',
+    }),
+    'array': frozenset({
+        'abs', 'avg', 'binary_search', 'binary_search_leftmost', 'binary_search_rightmost',
+        'clear', 'concat', 'copy', 'covariance', 'every', 'fill', 'first', 'from_items', 'get',
+        'includes', 'indexof', 'insert', 'join', 'last', 'lastindexof', 'max', 'median', 'min',
+        'mode', 'na_float', 'new', 'new_bool', 'new_box', 'new_color', 'new_float', 'new_int',
+        'new_label', 'new_line', 'new_linefill', 'new_string', 'new_table',
+        'percentile_linear_interpolation', 'percentile_nearest_rank', 'percentrank', 'pop',
+        'push', 'range', 'remove', 'reverse', 'set', 'shift', 'size', 'slice', 'some', 'sort',
+        'sort_indices', 'standardize', 'stdev', 'sum', 'unshift', 'variance',
+    }),
+    'barmerge': frozenset({
+        'gaps_off', 'gaps_on', 'lookahead_last_closed', 'lookahead_off', 'lookahead_on',
+    }),
+    'barstate': frozenset({
+        'isconfirmed', 'isfirst', 'ishistory', 'islast', 'islastconfirmedhistory', 'isnew',
+        'isrealtime',
+    }),
+    'box': frozenset({
+        'all', 'copy', 'delete', 'get_bottom', 'get_left', 'get_right', 'get_top', 'na_float',
+        'new', 'set_bgcolor', 'set_border_color', 'set_border_style', 'set_border_width',
+        'set_bottom', 'set_bottom_right_point', 'set_extend', 'set_left', 'set_lefttop',
+        'set_right', 'set_rightbottom', 'set_text', 'set_text_color', 'set_text_font_family',
+        'set_text_formatting', 'set_text_halign', 'set_text_size', 'set_text_valign',
+        'set_text_wrap', 'set_top', 'set_top_left_point', 'set_xloc',
+    }),
+    'chart': frozenset({
+        'bg_color', 'fg_color', 'is_heikinashi', 'is_kagi', 'is_linebreak', 'is_pnf',
+        'is_range', 'is_renko', 'is_standard', 'left_visible_bar_time', 'point',
+        'right_visible_bar_time',
+    }),
+    'color': frozenset({
+        'aqua', 'b', 'black', 'blue', 'from_gradient', 'fuchsia', 'g', 'gray', 'green', 'lime',
+        'maroon', 'navy', 'new', 'olive', 'orange', 'purple', 'r', 'red', 'rgb', 'silver', 't',
+        'teal', 'white', 'yellow',
+    }),
+    'currency': frozenset({
+        'AED', 'ARS', 'AUD', 'BDT', 'BHD', 'BRL', 'BTC', 'CAD', 'CHF', 'CLP', 'CNY', 'COP',
+        'CZK', 'DKK', 'EGP', 'ETH', 'EUR', 'GBP', 'HKD', 'HUF', 'IDR', 'ILS', 'INR', 'ISK',
+        'JPY', 'KES', 'KRW', 'KWD', 'LKR', 'MAD', 'MXN', 'MYR', 'NGN', 'NOK', 'NONE', 'NZD',
+        'PEN', 'PHP', 'PKR', 'PLN', 'QAR', 'RON', 'RSD', 'RUB', 'SAR', 'SEK', 'SGD', 'THB',
+        'TND', 'TRY', 'TWD', 'USD', 'USDT', 'VES', 'VND', 'ZAR',
+    }),
+    'dayofweek': frozenset({
+        'dayofweek', 'friday', 'monday', 'saturday', 'sunday', 'thursday', 'tuesday',
+        'wednesday',
+    }),
+    'display': frozenset({
+        'all', 'data_window', 'none', 'pane', 'price_scale', 'status_line',
+    }),
+    'dividends': frozenset({
+        'future_amount', 'future_ex_date', 'future_pay_date', 'gross', 'na_float', 'net',
+    }),
+    'earnings': frozenset({
+        'actual', 'estimate', 'future_eps', 'future_period_end_time', 'future_revenue',
+        'future_time', 'na_float', 'standardized',
+    }),
+    'extend': frozenset({
+        'both', 'left', 'none', 'right',
+    }),
+    'font': frozenset({
+        'family_default', 'family_monospace',
+    }),
+    'footprint': frozenset({
+        'buy_volume', 'delta', 'poc', 'sell_volume', 'total_volume', 'vah', 'val',
+    }),
+    'format': frozenset({
+        'inherit', 'mintick', 'percent', 'price', 'volume',
+    }),
+    'hline': frozenset({
+        'hline', 'style_dashed', 'style_dotted', 'style_solid',
+    }),
+    'label': frozenset({
+        'all', 'copy', 'delete', 'get_text', 'get_x', 'get_y', 'na_float', 'new', 'set_color',
+        'set_point', 'set_size', 'set_style', 'set_text', 'set_text_font_family',
+        'set_text_formatting', 'set_textalign', 'set_textcolor', 'set_tooltip', 'set_x',
+        'set_xloc', 'set_xy', 'set_y', 'set_yloc', 'style_arrowdown', 'style_arrowup',
+        'style_circle', 'style_cross', 'style_diamond', 'style_flag', 'style_label_center',
+        'style_label_down', 'style_label_left', 'style_label_lower_left',
+        'style_label_lower_right', 'style_label_right', 'style_label_up',
+        'style_label_upper_left', 'style_label_upper_right', 'style_none', 'style_square',
+        'style_text_outline', 'style_triangledown', 'style_triangleup', 'style_xcross',
+    }),
+    'line': frozenset({
+        'all', 'copy', 'delete', 'get_price', 'get_x1', 'get_x2', 'get_y1', 'get_y2',
+        'na_float', 'new', 'set_color', 'set_extend', 'set_first_point', 'set_second_point',
+        'set_style', 'set_width', 'set_x1', 'set_x2', 'set_xloc', 'set_xy1', 'set_xy2',
+        'set_y1', 'set_y2', 'style_arrow_both', 'style_arrow_left', 'style_arrow_right',
+        'style_dashed', 'style_dotted', 'style_solid',
+    }),
+    'linefill': frozenset({
+        'all', 'delete', 'get_line1', 'get_line2', 'new', 'set_color',
+    }),
+    'location': frozenset({
+        'abovebar', 'absolute', 'belowbar', 'bottom', 'top',
+    }),
+    'log': frozenset({
+        'broker_debug', 'broker_error', 'broker_info', 'broker_warning', 'error', 'handler',
+        'info', 'logger', 'ohlcv_info', 'setup_security_file_log', 'sim_info', 'warning',
+    }),
+    'map': frozenset({
+        'clear', 'contains', 'copy', 'get', 'keys', 'new', 'put', 'put_all', 'remove', 'size',
+        'values',
+    }),
+    'math': frozenset({
+        'abs', 'acos', 'asin', 'atan', 'avg', 'ceil', 'cos', 'e', 'exp', 'floor', 'log',
+        'log10', 'max', 'min', 'na_float', 'phi', 'pi', 'pow', 'random', 'round',
+        'round_to_mintick', 'rphi', 'sign', 'sin', 'sqrt', 'sum', 'tan', 'todegrees',
+        'toradians',
+    }),
+    'matrix': frozenset({
+        'add_col', 'add_row', 'all', 'annotations', 'avg', 'col', 'columns', 'concat', 'copy',
+        'delete', 'det', 'diff', 'eigenvalues', 'eigenvectors', 'elements_count', 'fill', 'get',
+        'inv', 'is_antidiagonal', 'is_antisymmetric', 'is_binary', 'is_diagonal', 'is_identity',
+        'is_square', 'is_stochastic', 'is_symmetric', 'is_triangular', 'is_zero', 'kron', 'max',
+        'median', 'min', 'mode', 'mult', 'na_float', 'new', 'pinv', 'pow', 'rank', 'remove_col',
+        'remove_row', 'reshape', 'reverse', 'row', 'rows', 'set', 'sort', 'submatrix', 'sum',
+        'swap_columns', 'swap_rows', 'trace', 'transpose',
+    }),
+    'order': frozenset({
+        'ascending', 'descending',
+    }),
+    'pivotpointtype': frozenset({
+        'camarilla', 'classic', 'dm', 'fibonacci', 'traditional', 'woodie',
+    }),
+    'plot': frozenset({
+        'linestyle_dashed', 'linestyle_dotted', 'linestyle_solid', 'plot', 'style_area',
+        'style_areabr', 'style_circles', 'style_columns', 'style_cross', 'style_histogram',
+        'style_line', 'style_linebr', 'style_stepline', 'style_stepline_diamond',
+        'style_steplinebr',
+    }),
+    'polyline': frozenset({
+        'all', 'delete', 'new', 'style_arrow_both', 'style_arrow_left', 'style_arrow_right',
+        'style_dashed', 'style_dotted', 'style_solid',
+    }),
+    'position': frozenset({
+        'bottom_center', 'bottom_left', 'bottom_right', 'middle_center', 'middle_left',
+        'middle_right', 'top_center', 'top_left', 'top_right',
+    }),
+    'request': frozenset({
+        'annotations', 'currency_rate', 'dividends', 'earnings', 'economic', 'financial',
+        'footprint', 'nan', 'quandl', 'security', 'security_lower_tf', 'seed', 'splits',
+    }),
+    'runtime': frozenset({
+        'error',
+    }),
+    'scale': frozenset({
+        'left', 'none', 'right',
+    }),
+    'session': frozenset({
+        'extended', 'isfirstbar', 'isfirstbar_regular', 'islastbar', 'islastbar_regular',
+        'ismarket', 'ispostmarket', 'ispremarket', 'regular',
+    }),
+    'shape': frozenset({
+        'arrowdown', 'arrowup', 'circle', 'cross', 'diamond', 'flag', 'labeldown', 'labelup',
+        'square', 'triangledown', 'triangleup', 'xcross',
+    }),
+    'size': frozenset({
+        'auto', 'huge', 'large', 'normal', 'small', 'tiny',
+    }),
+    'splits': frozenset({
+        'denominator', 'numerator',
+    }),
+    'strategy': frozenset({
+        'account_currency', 'avg_losing_trade', 'avg_losing_trade_percent', 'avg_trade',
+        'avg_trade_percent', 'avg_winning_trade', 'avg_winning_trade_percent', 'cancel',
+        'cancel_all', 'cash', 'close', 'close_all', 'closedtrades', 'commission',
+        'convert_to_account', 'convert_to_symbol', 'default_entry_qty', 'direction', 'entry',
+        'equity', 'eventrades', 'exit', 'fixed', 'grossloss', 'grossloss_percent',
+        'grossprofit', 'grossprofit_percent', 'initial_capital', 'long', 'losstrades',
+        'margin_liquidation_price', 'max_contracts_held_all', 'max_contracts_held_long',
+        'max_contracts_held_short', 'max_drawdown', 'max_drawdown_percent', 'max_runup',
+        'max_runup_percent', 'na_float', 'netprofit', 'netprofit_percent', 'oca', 'openprofit',
+        'openprofit_percent', 'opentrades', 'order', 'percent_of_equity', 'position_avg_price',
+        'position_entry_name', 'position_size', 'risk', 'short', 'wintrades',
+    }),
+    'string': frozenset({
+        'contains', 'endswith', 'format', 'format_time', 'length', 'lower', 'match', 'na_float',
+        'pos', 'repeat', 'replace', 'replace_all', 'split', 'startswith', 'substring',
+        'tonumber', 'tostring', 'trim', 'upper',
+    }),
+    'syminfo': frozenset({
+        'basecurrency', 'country', 'currency', 'current_contract', 'description', 'employees',
+        'expiration_date', 'industry', 'isin', 'main_tickerid', 'mincontract', 'minmove',
+        'mintick', 'na_float', 'period', 'pointvalue', 'prefix', 'pricescale',
+        'recommendations_buy', 'recommendations_buy_strong', 'recommendations_date',
+        'recommendations_hold', 'recommendations_sell', 'recommendations_sell_strong',
+        'recommendations_total', 'regular', 'root', 'sector', 'session', 'shareholders',
+        'shares_outstanding_float', 'shares_outstanding_total', 'target_price_average',
+        'target_price_date', 'target_price_estimates', 'target_price_high', 'target_price_low',
+        'target_price_median', 'ticker', 'tickerid', 'timezone', 'type', 'volumetype',
+    }),
+    'ta': frozenset({
+        'accdist', 'alma', 'atr', 'barssince', 'bb', 'bbw', 'cci', 'change', 'cmo', 'cog',
+        'correlation', 'cross', 'crossover', 'crossunder', 'cum', 'dev', 'dmi', 'ema',
+        'falling', 'highest', 'highestbars', 'hma', 'iii', 'kc', 'kcw', 'linreg', 'lowest',
+        'lowestbars', 'macd', 'max', 'median', 'mfi', 'min', 'mode', 'mom', 'na_float', 'nvi',
+        'obv', 'percentile_linear_interpolation', 'percentile_nearest_rank', 'percentrank',
+        'pivot_point_levels', 'pivothigh', 'pivotlow', 'pvi', 'pvt', 'range', 'rci', 'rising',
+        'rma', 'roc', 'rsi', 'sar', 'sma', 'stdev', 'stoch', 'supertrend', 'swma', 'tr', 'tsi',
+        'valuewhen', 'variance', 'vwap', 'vwma', 'wad', 'wma', 'wpr', 'wvad',
+    }),
+    'table': frozenset({
+        'all', 'cell', 'cell_set_bgcolor', 'cell_set_height', 'cell_set_text',
+        'cell_set_text_color', 'cell_set_text_font_family', 'cell_set_text_formatting',
+        'cell_set_text_halign', 'cell_set_text_size', 'cell_set_text_valign',
+        'cell_set_tooltip', 'cell_set_width', 'clear', 'delete', 'merge_cells', 'new',
+        'set_bgcolor', 'set_border_color', 'set_border_width', 'set_frame_color',
+        'set_frame_width', 'set_position',
+    }),
+    'text': frozenset({
+        'align_bottom', 'align_center', 'align_left', 'align_right', 'align_top', 'format_bold',
+        'format_italic', 'format_none', 'wrap_auto', 'wrap_none',
+    }),
+    'ticker': frozenset({
+        'heikinashi', 'inherit', 'kagi', 'linebreak', 'modify', 'new', 'pointfigure', 'renko',
+        'standard',
+    }),
+    'timeframe': frozenset({
+        'change', 'from_seconds', 'in_seconds', 'isdaily', 'isdwm', 'isintraday', 'isminutes',
+        'ismonthly', 'isseconds', 'isticks', 'isweekly', 'main_period', 'multiplier', 'period',
+    }),
+    'volume_row': frozenset({
+        'buy_volume', 'delta', 'down_price', 'sell_volume', 'total_volume', 'up_price',
+    }),
+    'xloc': frozenset({
+        'bar_index', 'bar_time',
+    }),
+    'yloc': frozenset({
+        'abovebar', 'belowbar', 'price',
+    }),
+}

pine2pyne/node_ids.py

@@ -0,0 +1,235 @@
+"""The numbers PyneComp gives the blocks of a script: the suffix of a renamed local.
+
+A local that shadows a name, or is named like a function of the script, is
+spelled ``<name>__<n>__`` by PyneComp, ``n`` eight hex digits. ``n`` is the id
+its parser gave the block the local is declared in. The parser numbers some
+nodes, from 1, as it finishes them (post-order, in source order):
+
+* a call, except a cast (``int(x)``, ``label(na)``) and Pine v4's ``iff()``,
+  which is parsed as a conditional;
+* a history read ``x[n]``;
+* every block: a function body (a one-line body too), each branch of an
+  ``if``/``else if``/``else``, each case of a ``switch``, a loop body;
+* a ``type`` or ``enum`` declaration.
+
+Pine v4 is converted while it is parsed and the nodes the conversion creates
+are numbered too: a constant colour merged with ``transp`` (or with v4's
+default transparency) is a ``color.new()`` call. (The session conversion of
+``time()``, two more calls, is in the tree already: :mod:`.legacy_sessions`.)
+
+Measured with probe scripts compiled by PyneComp v6.0.80 (``tmp/probes``):
+a meter function ``m(x) => m = x`` between two constructs reads how many ids
+the construct takes. On the reference corpus the numbering names 87 of the 92
+modules with such locals that pine2pyne parses.
+"""
+from __future__ import annotations
+
+import dataclasses
+from typing import Dict, Optional
+
+from .legacy_sessions import SESSION_HELPER
+from .ast_nodes import (
+    ASTNode, Assignment, EnumDecl, ExpressionStatement, ForInLoop, ForLoop, FuncDecl, FunctionCall, Identifier,
+    IfExpression, IfStatement, IndexAccess, InputDecl, Literal, MemberAccess, MethodCall, Script, SwitchExpression,
+    SwitchStatement, TupleDestructure, TypeDecl, WhileLoop,
+)
+
+#: calls that are casts: no node of their own
+_CASTS = frozenset({'int', 'float', 'bool', 'string', 'color', 'line', 'label', 'box', 'table', 'linefill',
+                    'polyline', 'iff'})
+_NAMED_COLOURS = frozenset({
+    'aqua', 'black', 'blue', 'fuchsia', 'gray', 'green', 'lime', 'maroon', 'navy', 'olive', 'orange',
+    'purple', 'red', 'silver', 'teal', 'white', 'yellow'})
+#: Pine v4 calls whose colour takes ``transp``: the colour keywords, (colour, transp) positions
+_V4_COLOUR_KEYWORDS = {'plot': ('color',), 'plotshape': ('color', 'textcolor'), 'plotchar': ('color',),
+                       'plotarrow': ('colorup', 'colordown'), 'fill': ('color',)}
+_V4_COLOUR_POSITIONS = {'plot': (2, None), 'plotshape': (4, 5), 'plotchar': (4, 5), 'fill': (2, 3)}
+
+
+def hex_suffixed(name: str, block_id: int) -> str:
+    """PyneComp's spelling of a renamed local of block ``block_id``."""
+    return f'{name}__{block_id:08x}__'
+
+
+class BlockNumbers:
+    """The id of every block of a script, by the identity of its statement list
+    (or of the function, for a one-line body). Built once per script."""
+
+    def __init__(self, script: Script) -> None:
+        version_text = getattr(script.version, 'version', '') if script.version else ''
+        self._version = int(version_text) if str(version_text).isdigit() else 6
+        self._count = 0
+        self._ids: Dict[int, int] = {}
+        items = sorted(list(script.declarations) + list(script.body),
+                       key=lambda item: (getattr(item, 'line', 0), getattr(item, 'column', 0)))
+        self._constant_colour_names = self._constant_colours(items) if self._version <= 4 else frozenset()
+        if script.script_decl is not None:
+            for value in script.script_decl.kwargs.values():
+                self._expression(value)
+            self._take()
+        for item in items:
+            self._statement(item)
+
+    def of(self, block) -> int:
+        """The id of a statement list (or of a FuncDecl's body); 0 when unknown."""
+        return self._ids.get(id(block), 0)
+
+    # ------------------------------------------------------------ numbering
+
+    def _take(self) -> int:
+        self._count += 1
+        return self._count
+
+    def _block(self, statements, owner: Optional[object] = None) -> None:
+        if isinstance(statements, list):
+            for statement in statements:
+                self._statement(statement)
+        else:
+            self._expression(statements)
+        number = self._take()
+        self._ids[id(statements)] = number
+        if owner is not None:
+            self._ids[id(owner)] = number
+
+    def _statement(self, node) -> None:
+        if isinstance(node, FuncDecl):
+            if node.name == SESSION_HELPER:
+                return  # PyneComp's own helper
+            for parameter in node.params:
+                self._expression(parameter.default)
+            self._block(node.body, owner=node)
+        elif isinstance(node, IfStatement):
+            self._expression(node.condition)
+            self._block(node.body)
+            for condition, body in node.elseifs:
+                self._expression(condition)
+                self._block(body)
+            if node.else_body is not None:
+                self._block(node.else_body)
+        elif isinstance(node, ForLoop):
+            for value in (node.from_val, node.to_val, node.step):
+                self._expression(value)
+            self._block(node.body)
+        elif isinstance(node, ForInLoop):
+            self._expression(node.iterable)
+            self._block(node.body)
+        elif isinstance(node, WhileLoop):
+            self._expression(node.condition)
+            self._block(node.body)
+        elif isinstance(node, (SwitchStatement, SwitchExpression)):
+            self._switch(node)
+        elif isinstance(node, InputDecl):
+            for value in list(node.args) + list(node.kwargs.values()):
+                self._expression(value)
+            self._take()
+        elif isinstance(node, (TypeDecl, EnumDecl)):
+            self._take()
+        else:
+            self._expression(node)
+
+    def _switch(self, node) -> None:
+        self._expression(node.expr)
+        for case, body in node.cases:
+            self._expression(case)
+            self._block(body)
+        if node.default is not None:
+            self._block(node.default)
+
+    def _expression(self, node) -> None:
+        if node is None or not isinstance(node, (ASTNode, list)):
+            return
+        if isinstance(node, list):
+            for item in node:
+                self._statement(item)
+            return
+        if isinstance(node, TupleDestructure):
+            return  # the names only: its value is the assignment's
+        if isinstance(node, FunctionCall):
+            if not isinstance(node.func, str):
+                self._expression(node.func)
+            for value in list(node.args) + list(node.kwargs.values()):
+                self._expression(value)
+            if isinstance(node.func, str) and node.func in _CASTS:
+                return
+            if self._version <= 4 and isinstance(node.func, str):
+                self._v4_conversion(node)
+            self._take()
+            return
+        if isinstance(node, MethodCall):
+            self._expression(node.object)
+            for value in list(node.args) + list(node.kwargs.values()):
+                self._expression(value)
+            self._take()
+            return
+        if isinstance(node, IndexAccess):
+            self._expression(node.object)
+            self._expression(node.index)
+            self._take()
+            return
+        if isinstance(node, IfExpression):
+            self._expression(node.condition)
+            self._block(node.true_expr)
+            if node.false_expr is not None:
+                self._block(node.false_expr)
+            return
+        if isinstance(node, SwitchExpression):
+            self._switch(node)
+            return
+        if isinstance(node, (Assignment, ExpressionStatement)) or dataclasses.is_dataclass(node):
+            for field in dataclasses.fields(node):
+                if field.name in ('line', 'column'):
+                    continue
+                self._child(getattr(node, field.name))
+
+    def _child(self, value) -> None:
+        if isinstance(value, ASTNode):
+            self._expression(value)
+        elif isinstance(value, (list, tuple)):
+            for item in value:
+                self._child(item)
+        elif isinstance(value, dict):
+            for item in value.values():
+                self._child(item)
+
+    # ------------------------------------------------------------ Pine v4 conversion
+
+    def _v4_conversion(self, call: FunctionCall) -> None:
+        """The calls Pine v4's conversion adds around ``call``."""
+        if call.func in _V4_COLOUR_KEYWORDS:
+            for _ in range(self._merged_colours(call)):
+                self._take()  # color.new(c, transp)
+
+    def _merged_colours(self, call: FunctionCall) -> int:
+        function = call.func
+        transparency = call.kwargs.get('transp')
+        colour_index, transp_index = _V4_COLOUR_POSITIONS.get(function, (None, None))
+        if transp_index is not None and len(call.args) > transp_index:
+            transparency = call.args[transp_index]
+        colours = [call.kwargs[key] for key in _V4_COLOUR_KEYWORDS[function] if key in call.kwargs]
+        if colour_index is not None and len(call.args) > colour_index:
+            colours.append(call.args[colour_index])
+        merged = 0
+        for colour in colours:
+            if self._is_constant_colour(colour):
+                merged += 1
+            elif transparency is not None and function == 'fill' and not isinstance(colour, Literal):
+                merged += 1
+        return merged
+
+    def _is_constant_colour(self, value) -> bool:
+        if isinstance(value, Literal):
+            return value.literal_type == 'color'
+        if isinstance(value, Identifier):
+            return value.name in self._constant_colour_names or (
+                value.name.startswith('color.') and value.name[len('color.'):] in _NAMED_COLOURS)
+        return isinstance(value, MemberAccess) and value.object == 'color' and value.member in _NAMED_COLOURS
+
+    def _constant_colours(self, items) -> frozenset:
+        """Top-level names bound once, to a constant colour."""
+        bindings: Dict[str, list] = {}
+        for item in items:
+            if isinstance(item, Assignment) and isinstance(item.target, str):
+                bindings.setdefault(item.target, []).append(item.value)
+        self._constant_colour_names = frozenset()
+        return frozenset(name for name, values in bindings.items()
+                         if len(values) == 1 and self._is_constant_colour(values[0]))

pine2pyne/once_lowering.py

@@ -0,0 +1,75 @@
+"""
+`once` lowering: Pine v6's `once` structure as a persistent flag plus an `if`.
+
+    once close > mySMA            var bool once_fired1 = false
+        printLabel(...)     ->    if not once_fired1 and close > mySMA
+                                      once_fired1 := true
+                                      printLabel(...)
+
+This is the equivalent code the Pine v6 User Manual gives for `once`
+("Conditional structures", section "`once` structure"): the block runs the
+first time its condition is true and never again. The condition is optional
+and `true` by default, so a bare `once` checks only its flag. `and`
+short-circuits, so the condition is not evaluated once the structure fired
+("evaluated only once ... and then never again after that"). The flag is set
+before the block, so a `break` or `continue` in it cannot skip that.
+
+The flag is a `var`, so it has a `var`'s scope: one per function call site,
+one for all iterations of a loop, initialised the first time its block runs.
+The lowering runs at the end of parsing, so no later stage sees a `once`
+(card #59).
+"""
+import dataclasses
+
+from .ast_nodes import (
+    BinaryOp, Identifier, IfStatement, Literal, OnceStatement, Reassignment,
+    Script, UnaryOp, VarDecl,
+)
+from .ast_walk import contains, is_node
+from .scope_renamer import collect_names, fresh_name
+
+FLAG_STEM = 'once_fired'
+
+
+def lower_once_structures(script: Script) -> Script:
+    """Return a copy of `script` with every `once` structure lowered to a
+    `var` flag and an `if`. A script without one is returned unchanged."""
+    if not contains(script, lambda node: isinstance(node, OnceStatement)):
+        return script
+    return _OnceLowering(collect_names(script)).rebuild(script)
+
+
+class _OnceLowering:
+    def __init__(self, used_names):
+        self.used_names = used_names
+
+    def rebuild(self, value):
+        """`value` with each statement list's `once` structures expanded in place."""
+        if isinstance(value, list):
+            lowered = []
+            for item in value:
+                rebuilt = self.rebuild(item)
+                lowered.extend(self.flag_and_if(rebuilt) if isinstance(rebuilt, OnceStatement) else [rebuilt])
+            return lowered
+        if isinstance(value, tuple):
+            return tuple(self.rebuild(item) for item in value)
+        if isinstance(value, dict):
+            return {key: self.rebuild(item) for key, item in value.items()}
+        if not is_node(value):
+            return value
+        children = {field.name: self.rebuild(getattr(value, field.name))
+                    for field in dataclasses.fields(value) if field.name not in ('line', 'column')}
+        return dataclasses.replace(value, **children)
+
+    def flag_and_if(self, once: OnceStatement) -> list:
+        position = {'line': once.line, 'column': once.column}
+        flag = fresh_name(FLAG_STEM, self.used_names)
+        not_fired = UnaryOp(op='not', operand=Identifier(name=flag, **position), **position)
+        condition = not_fired if once.condition is None else BinaryOp(
+            left=not_fired, op='and', right=once.condition, **position)
+        fired = Reassignment(target=flag, value=Literal(value=True, literal_type='bool', **position), **position)
+        return [
+            VarDecl(name=flag, value=Literal(value=False, literal_type='bool', **position), type_hint='bool',
+                    **position),
+            IfStatement(condition=condition, body=[fired] + once.body, **position),
+        ]