@pineforge/codegen-pyodide 0.10.3 → 1.0.0-rc.1

package/pineforge_codegen/session_reads.py

@@ -0,0 +1,84 @@
+"""The ``session.*`` flag reads at a history offset that generated C++ holds.
+
+``session.ismarket[1]`` and the other ``session.<flag>[k]`` reads need state:
+a Series per flag at the top level, one per call site inside a function
+(codegen). A read the codegen never emits needs none: it sits in a call the
+codegen skips with all its arguments (``plot``, ``alert``, the ``table.*``
+namespace, ...: codegen/tables.py ``SKIP_FUNC_NAMES`` / ``SKIP_NAMESPACES``,
+and ``max_bars_back``) or in a ``strategy.*`` parameter it drops
+(support_checker.py ``STRATEGY_UNSUPPORTED_PARAMS``, e.g. ``alert_message``).
+The analyzer (which functions may be emitted once per call site) and the
+codegen (which reads get a Series) ask this module the same question. The
+C++ decides which of those functions get clones: ``pineforge_codegen._generate``
+clones only the functions whose reads a pass's C++ holds, so a read it
+counts that the codegen leaves out some other way (it renders the argument,
+then drops it: ``color.from_gradient``, a drawing's xloc) costs nothing, or an
+unused Series in a function cloned for another read. One it leaves out that
+the codegen does emit finds no Series and is refused, never given shared
+state.
+"""
+
+from __future__ import annotations
+
+from .ast_nodes import FuncCall, Identifier, MemberAccess, Subscript
+from .limits import syntax_children
+from .signatures import SESSION_FLAG_MEMBERS, get_param_names
+
+
+def is_session_history(node) -> bool:
+    """Whether ``node`` is a ``session.*`` flag read at an offset
+    (``session.ismarket[1]``)."""
+    return (isinstance(node, Subscript)
+            and isinstance(node.object, MemberAccess)
+            and isinstance(node.object.object, Identifier)
+            and node.object.object.name == "session"
+            and node.object.member in SESSION_FLAG_MEMBERS)
+
+
+def _dropped_arguments(call: FuncCall) -> list:
+    """The arguments of ``call`` the codegen never visits: all of a skipped
+    call's, a ``strategy.*`` call's unsupported parameters."""
+    # Imported here: the codegen package imports the analyzer, which imports
+    # this module.
+    from .codegen.tables import SKIP_FUNC_NAMES, SKIP_NAMESPACES, SKIP_VAR_TYPES
+    from .support_checker import STRATEGY_UNSUPPORTED_PARAMS
+
+    callee = call.callee
+    everything = [*call.args, *call.kwargs.values()]
+    if isinstance(callee, Identifier):
+        if callee.name in SKIP_FUNC_NAMES or callee.name == "max_bars_back":
+            return everything
+        return []
+    if not (isinstance(callee, MemberAccess) and isinstance(callee.object, Identifier)):
+        return []
+    namespace, name = callee.object.name, callee.member
+    if namespace in SKIP_NAMESPACES or namespace in SKIP_VAR_TYPES:
+        return everything
+    if namespace == "strategy" and name in STRATEGY_UNSUPPORTED_PARAMS:
+        dropped = STRATEGY_UNSUPPORTED_PARAMS[name]
+        params = get_param_names("strategy", name) or []
+        return ([value for key, value in call.kwargs.items() if key in dropped]
+                + [arg for index, arg in enumerate(call.args)
+                   if index < len(params) and params[index] in dropped])
+    return []
+
+
+def emitted_session_reads(root, skip: frozenset[int] | set[int] = frozenset()) -> list[Subscript]:
+    """Every ``session.<flag>[k]`` under ``root`` the codegen emits, leaving
+    out the subtrees whose node id is in ``skip`` (a request.security
+    expression, whose reads keep the requested clock's history)."""
+    reads: list[Subscript] = []
+    stack = [root]
+    while stack:
+        node = stack.pop()
+        if node is None or id(node) in skip:
+            continue
+        if is_session_history(node):
+            reads.append(node)
+        children = list(syntax_children(node))
+        if isinstance(node, FuncCall):
+            dropped = {id(arg) for arg in _dropped_arguments(node)}
+            if dropped:
+                children = [child for child in children if id(child) not in dropped]
+        stack.extend(children)
+    return reads

package/pineforge_codegen/signatures.py

@@ -79,7 +79,7 @@ def _func(name: str, *sigs: FuncSig) -> IntrinsicFunc:
 
 # Shortcuts for common param types
 F = PineType.FLOAT
-I = PineType.INT
+I = PineType.INT  # noqa: E741 - signature table uses single-letter type aliases
 B = PineType.BOOL
 S = PineType.STRING
 NA = PineType.NA
@@ -95,6 +95,12 @@ TA_FUNCTIONS: dict[str, IntrinsicFunc] = {}
 def _ta(short_name: str, *sigs: FuncSig) -> None:
     TA_FUNCTIONS[short_name] = _func(f"ta.{short_name}", *sigs)
 
+# Parameter names, order and the required/optional split are TradingView's
+# (Pine v6 reference): the support checker binds every ta.* call to one of
+# these signatures and refuses an argument that binds to no parameter
+# (``_check_ta_arguments``). A default marks an optional parameter; None, a
+# required one.
+
 # --- Moving Averages ---
 _ta("sma",     _sig([("source", F), ("length", I)]))
 _ta("ema",     _sig([("source", F), ("length", I)]))
@@ -102,9 +108,10 @@ _ta("rma",     _sig([("source", F), ("length", I)]))
 _ta("wma",     _sig([("source", F), ("length", I)]))
 _ta("hma",     _sig([("source", F), ("length", I)]))
 _ta("vwma",    _sig([("source", F), ("length", I)]))
-_ta("alma",    _sig([("source", F), ("length", I), ("offset", F, 0.85), ("sigma", F, 6.0)]))
+_ta("alma",    _sig([("series", F), ("length", I), ("offset", F), ("sigma", F),
+                     ("floor", B, False)]))
 _ta("swma",    _sig([("source", F)]))
-_ta("linreg",  _sig([("source", F), ("length", I), ("offset", I, 0)]))
+_ta("linreg",  _sig([("source", F), ("length", I), ("offset", I)]))
 
 # --- Oscillators ---
 _ta("rsi",     _sig([("source", F), ("length", I)]))
@@ -113,7 +120,7 @@ _ta("cci",     _sig([("source", F), ("length", I)]))
 _ta("mfi",     _sig([("series", F), ("length", I)]))
 _ta("mom",     _sig([("source", F), ("length", I)]))
 _ta("roc",     _sig([("source", F), ("length", I)]))
-_ta("cmo",     _sig([("source", F), ("length", I)]))
+_ta("cmo",     _sig([("series", F), ("length", I)]))
 _ta("tsi",     _sig([("source", F), ("short_length", I), ("long_length", I)]))
 _ta("wpr",     _sig([("length", I)]))
 _ta("cog",     _sig([("source", F), ("length", I)]))
@@ -123,12 +130,12 @@ _ta("macd",    _sig([("source", F), ("fastlen", I), ("slowlen", I), ("siglen", I
                     returns_tuple=True, tuple_count=3))
 
 # --- Bollinger Bands / Keltner ---
-_ta("bb",      _sig([("source", F), ("length", I), ("mult", F, 2.0)],
+_ta("bb",      _sig([("series", F), ("length", I), ("mult", F)],
                     returns_tuple=True, tuple_count=3))
-_ta("kc",      _sig([("source", F), ("length", I), ("mult", F, 1.5)],
+_ta("kc",      _sig([("series", F), ("length", I), ("mult", F), ("useTrueRange", B, True)],
                     returns_tuple=True, tuple_count=3))
-_ta("bbw",     _sig([("source", F), ("length", I), ("mult", F, 2.0)]))
-_ta("kcw",     _sig([("source", F), ("length", I), ("mult", F, 1.5)]))
+_ta("bbw",     _sig([("series", F), ("length", I), ("mult", F)]))
+_ta("kcw",     _sig([("series", F), ("length", I), ("mult", F), ("useTrueRange", B, True)]))
 
 # --- Volatility & Range ---
 _ta("atr",     _sig([("length", I)]))
@@ -141,7 +148,7 @@ _ta("supertrend", _sig([("factor", F), ("atrPeriod", I)],
                        returns_tuple=True, tuple_count=2))
 _ta("dmi",     _sig([("diLength", I), ("adxSmoothing", I)],
                     returns_tuple=True, tuple_count=3))
-_ta("sar",     _sig([("start", F, 0.02), ("inc", F, 0.02), ("max", F, 0.2)]))
+_ta("sar",     _sig([("start", F), ("inc", F), ("max", F)]))
 
 # --- Crossover / State ---
 _ta("crossover",  _sig([("source1", F), ("source2", F)], ret=B))
@@ -161,8 +168,14 @@ _ta("highest",
 _ta("lowest",
     _sig([("source", F), ("length", I)]),
     _sig([("length", I)]))
-_ta("highestbars", _sig([("source", F), ("length", I)], ret=I))
-_ta("lowestbars",  _sig([("source", F), ("length", I)], ret=I))
+# ta.highestbars / ta.lowestbars: "One arg version: length is the number of
+# bars back. Algorithm uses high [low] as a source series."
+_ta("highestbars",
+    _sig([("source", F), ("length", I)], ret=I),
+    _sig([("length", I)], ret=I))
+_ta("lowestbars",
+    _sig([("source", F), ("length", I)], ret=I),
+    _sig([("length", I)], ret=I))
 _ta("median",      _sig([("source", F), ("length", I)]))
 _ta("percentrank", _sig([("source", F), ("length", I)]))
 _ta("percentile_nearest_rank",       _sig([("source", F), ("length", I), ("percentage", F)]))
@@ -180,14 +193,17 @@ _ta("pivotlow",
     _sig([("leftbars", I), ("rightbars", I)]))
 
 # --- Volume indicators ---
-# ta.vwap has TWO overloads:
-#   ta.vwap(source, anchor, stdev_mult)      — 3-arg bands form (primary), returns [vwap, upper, lower]
-#   ta.vwap(source)                          — scalar 1-arg form (daily anchor)
-# Note: primary is the 3-arg form so param_names covers all kwargs; the
-# analyzer remaps 3-arg calls to the internal "vwap_bands" dispatch key.
-_ta("vwap",    _sig([("source", F), ("anchor", B), ("stdev_mult", F)],
+# ta.vwap has TWO overloads (TradingView):
+#   ta.vwap(source, anchor, stdev_mult)      — bands form (primary), returns [vwap, upper, lower]
+#   ta.vwap(source, anchor)                  — scalar form
+# ``anchor`` is optional in both ("The default is equivalent to passing
+# timeframe.change() with "1D" as its argument"). The primary is the widest
+# form so param_names covers every keyword; the analyzer remaps the bands
+# form to the internal "vwap_bands" dispatch key.
+_VWAP_DAILY_ANCHOR = 'timeframe.change("1D")'
+_ta("vwap",    _sig([("source", F), ("anchor", B, _VWAP_DAILY_ANCHOR), ("stdev_mult", F)],
                     returns_tuple=True, tuple_count=3),
-               _sig([("source", F)]))
+               _sig([("source", F), ("anchor", B, _VWAP_DAILY_ANCHOR)]))
 
 # --- Statistical (additional) ---
 _ta("mode",    _sig([("source", F), ("length", I)]))
@@ -337,7 +353,7 @@ _str("tostring",
      _sig([("value", F)], ret=S),
      _sig([("value", F), ("format", S)], ret=S))
 _str("tonumber",    _sig([("string", S)], ret=F))
-_str("format",      _sig([("formatStr", S)], ret=S))  # variadic
+_str("format",      _sig([("formatString", S)], ret=S))  # variadic
 _str("format_time", _sig([("time", I), ("format", S), ("timezone", S, "")], ret=S))
 _str("length",      _sig([("string", S)], ret=I))
 _str("contains",    _sig([("source", S), ("str", S)], ret=B))
@@ -352,7 +368,7 @@ _str("replace_all", _sig([("source", S), ("target", S), ("replacement", S)], ret
 _str("lower",       _sig([("source", S)], ret=S))
 _str("upper",       _sig([("source", S)], ret=S))
 _str("trim",        _sig([("source", S)], ret=S))
-_str("repeat",      _sig([("source", S), ("count", I)], ret=S))
+_str("repeat",      _sig([("source", S), ("repeat", I), ("separator", S, "")], ret=S))
 _str("match",       _sig([("source", S), ("regex", S)], ret=S))
 _str("split",       _sig([("string", S), ("separator", S)], ret=S))  # returns array<string>
 
@@ -403,9 +419,9 @@ def _builtin(name: str, *sigs: FuncSig) -> None:
 
 _builtin("na",       _sig([("x", F)], ret=B))
 _builtin("nz",
-         _sig([("x", F)], ret=F),
-         _sig([("x", F), ("y", F)], ret=F))
-_builtin("fixnan",   _sig([("x", F)], ret=F))
+         _sig([("source", F)], ret=F),
+         _sig([("source", F), ("replacement", F)], ret=F))
+_builtin("fixnan",   _sig([("source", F)], ret=F))
 _builtin("timestamp",
          _sig([("year", I), ("month", I), ("day", I),
                ("hour", I, 0), ("minute", I, 0), ("second", I, 0)], ret=I))
@@ -523,6 +539,13 @@ BUILTIN_VARIABLES: dict[str, PineType] = {
     "session.islastbar": B, "session.islastbar_regular": B,
 }
 
+# The session.* booleans (session.ismarket ... session.islastbar_regular): the
+# flags a script can read at a history offset, ``session.ismarket[1]``.
+SESSION_FLAG_MEMBERS = frozenset(
+    name.split(".", 1)[1] for name, ptype in BUILTIN_VARIABLES.items()
+    if name.startswith("session.") and ptype == B
+)
+
 # Strategy variables (read-only properties, not function calls)
 STRATEGY_VARIABLES: dict[str, PineType] = {
     "strategy.position_size": F,
@@ -674,6 +697,8 @@ DISPLAY_VARIABLES: dict[str, PineType] = {
 TA_DEFAULT_SOURCE = {
     "highest": "high",
     "lowest": "low",
+    "highestbars": "high",
+    "lowestbars": "low",
     "pivothigh": "high",
     "pivotlow": "low",
 }