@hoox-sh/pynets 0.1.0 → 0.2.0

package/src/runtime/compile/helpers.ts

@@ -0,0 +1,140 @@
+/**
+ * Copyright (C) 2024-2026 jango_blockchained
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * na-safe arithmetic / compare / history for the JS compile backend.
+ * Python analog: pynescript.compiler.numba_builtins (object-mode subset).
+ */
+export const NA = null;
+
+export function isNaCell(v: unknown): boolean {
+  if (v == null) return true;
+  if (typeof v === "number") return !Number.isFinite(v);
+  return false;
+}
+
+export function naNum(v: unknown): number | null {
+  if (isNaCell(v)) return NA;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (typeof v === "number") return v;
+  return NA;
+}
+
+/** Store cell or object handle. Objects (array/map/matrix/UDT) stay intact. */
+export function hold(v: unknown): unknown {
+  if (v != null && typeof v === "object") return v;
+  return naNum(v);
+}
+
+export function pineEq(a: unknown, b: unknown): boolean {
+  const an = isNaCell(a);
+  const bn = isNaCell(b);
+  if (an && bn) return true;
+  if (an || bn) return false;
+  return a === b;
+}
+
+export function pineNe(a: unknown, b: unknown): boolean {
+  const an = isNaCell(a);
+  const bn = isNaCell(b);
+  if (an || bn) return false;
+  return a !== b;
+}
+
+export function pineLt(a: unknown, b: unknown): boolean {
+  if (isNaCell(a) || isNaCell(b)) return false;
+  return (a as number) < (b as number);
+}
+
+export function pineLtE(a: unknown, b: unknown): boolean {
+  if (isNaCell(a) || isNaCell(b)) return false;
+  return (a as number) <= (b as number);
+}
+
+export function pineGt(a: unknown, b: unknown): boolean {
+  if (isNaCell(a) || isNaCell(b)) return false;
+  return (a as number) > (b as number);
+}
+
+export function pineGtE(a: unknown, b: unknown): boolean {
+  if (isNaCell(a) || isNaCell(b)) return false;
+  return (a as number) >= (b as number);
+}
+
+function bin(a: unknown, b: unknown, op: (x: number, y: number) => number): number | null {
+  const x = naNum(a);
+  const y = naNum(b);
+  if (x == null || y == null) return NA;
+  const r = op(x, y);
+  return Number.isFinite(r) ? r : NA;
+}
+
+export function safeAdd(a: unknown, b: unknown): number | null {
+  return bin(a, b, (x, y) => x + y);
+}
+
+export function safeSub(a: unknown, b: unknown): number | null {
+  return bin(a, b, (x, y) => x - y);
+}
+
+export function safeMul(a: unknown, b: unknown): number | null {
+  return bin(a, b, (x, y) => x * y);
+}
+
+export function safeDiv(a: unknown, b: unknown): number | null {
+  return bin(a, b, (x, y) => x / y);
+}
+
+export function safeMod(a: unknown, b: unknown): number | null {
+  return bin(a, b, (x, y) => x % y);
+}
+
+export function safeNeg(a: unknown): number | null {
+  const x = naNum(a);
+  if (x == null) return NA;
+  const r = -x;
+  return Number.isFinite(r) ? r : NA;
+}
+
+export function nz(v: unknown, fallback: unknown = 0): number | null {
+  if (isNaCell(v)) {
+    const f = naNum(fallback);
+    return f == null ? 0 : f;
+  }
+  return naNum(v);
+}
+
+/** History: arr[bar - offset]. OOB / negative offset → na. [0] is current. */
+export function histGet(arr: Array<number | null>, bar: number, offset: unknown): number | null {
+  const off = naNum(offset);
+  if (off == null || off < 0 || !Number.isFinite(off)) return NA;
+  const i = bar - Math.trunc(off);
+  if (i < 0 || i >= arr.length) return NA;
+  return naNum(arr[i]);
+}
+
+export function histStore(arr: Array<number | null>, bar: number, value: unknown): void {
+  if (bar < 0 || bar >= arr.length) return;
+  arr[bar] = naNum(value);
+}
+
+export function defaultVolume(n: number): Array<number | null> {
+  return Array.from({ length: n }, () => 1);
+}
+
+export function defaultTime(n: number): Array<number | null> {
+  return Array.from({ length: n }, (_, i) => i * 60_000);
+}
+
+export function toFloatArr(
+  xs: ArrayLike<number | null | undefined> | null | undefined,
+  n: number,
+  missing: number | null,
+): Array<number | null> {
+  const out: Array<number | null> = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const v = xs != null && i < xs.length ? xs[i] : missing;
+    out[i] = naNum(v ?? missing);
+  }
+  return out;
+}

package/src/runtime/compile/index.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (C) 2024-2026 jango_blockchained
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * Public compile surface. Names match Python pynescript.compiler where they
+ * apply: compileScript, transpile, CompiledScript, clearCompileCache.
+ * Backend is JS emit only (Python object-mode analog — no Numba).
+ */
+export {
+  CompileError,
+  CompileEmitError,
+  CompileIneligibleError,
+  CompileLoadError,
+} from "./types.ts";
+export type {
+  CompileBackend,
+  CompileCacheStats,
+  CompileEligibility,
+  CompilePlotMeta,
+  CompiledScript,
+  RuntimeMode,
+} from "./types.ts";
+export {
+  compileEligible,
+  compileScript,
+  clearCompileCache,
+  compileCacheStats,
+  transpile,
+  runScript,
+  compileToResult,
+} from "./engine.ts";
+export type { CompileScriptExtras, CompileRunExtras } from "./engine.ts";
+export { emitScript } from "./emit.ts";

package/src/runtime/compile/runtime.ts

@@ -0,0 +1,297 @@
+/**
+ * Copyright (C) 2024-2026 jango_blockchained
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * Helpers object injected as `__h` into generated execute_script_compiled.
+ */
+import {
+  asColor,
+  colorB,
+  colorByName,
+  colorFromGradient,
+  colorG,
+  colorNew,
+  colorR,
+  colorRgb,
+  colorT,
+} from "../color.ts";
+import {
+  mathAbs,
+  mathAcos,
+  mathAsin,
+  mathAtan,
+  mathAvg,
+  mathCeil,
+  mathCos,
+  mathExp,
+  mathFixnan,
+  mathFloor,
+  mathIff,
+  mathLog10,
+  mathMax,
+  mathMin,
+  mathPow,
+  mathRound,
+  mathSign,
+  mathSin,
+  mathSqrt,
+  mathTan,
+  mathToDegrees,
+  mathToRadians,
+} from "../math.ts";
+import {
+  strContains,
+  strEndsWith,
+  strFormat,
+  strFormatTime,
+  strLength,
+  strLower,
+  strReplace,
+  strStartsWith,
+  strSubstring,
+  strToNumber,
+  strTostring,
+  strTrim,
+  strUpper,
+} from "../str.ts";
+import { LogBook, formatLogParts } from "../log.ts";
+import { resolveCurrencyRate } from "../request.ts";
+import { TaEngine } from "../ta.ts";
+import { utcPartsFromMs, timestamp, weekOfYear, timeTradingDay, type UtcParts } from "../time.ts";
+import { timeframeInSeconds } from "../timeframe.ts";
+import { compileArray, compileMap, compileMatrix } from "./collections.ts";
+import { createCompileDraw } from "./draw.ts";
+import {
+  histGet,
+  histStore,
+  hold,
+  isNaCell,
+  naNum,
+  nz,
+  pineEq,
+  pineGt,
+  pineGtE,
+  pineLt,
+  pineLtE,
+  pineNe,
+  safeAdd,
+  safeDiv,
+  safeMod,
+  safeMul,
+  safeNeg,
+  safeSub,
+} from "./helpers.ts";
+import { createCompileStrategy } from "./strategy.ts";
+import { udtGet, udtNew, udtRegister, udtSet } from "./udt_runtime.ts";
+
+export type CompileHelperInputs = Record<string, number | string | boolean>;
+
+export type CompileHelperOpts = {
+  inputs?: CompileHelperInputs;
+};
+
+export function createCompileHelpers(opts?: CompileHelperOpts) {
+  const ta = new TaEngine();
+  const inputs = opts?.inputs;
+  const book = new LogBook();
+  return {
+    na: NA_FN,
+    nz,
+    naNum,
+    isNa: isNaCell,
+    eq: pineEq,
+    ne: pineNe,
+    lt: pineLt,
+    lte: pineLtE,
+    gt: pineGt,
+    gte: pineGtE,
+    add: safeAdd,
+    sub: safeSub,
+    mul: safeMul,
+    div: safeDiv,
+    mod: safeMod,
+    neg: safeNeg,
+    hist: histGet,
+    store: histStore,
+    ta,
+    strategy: createCompileStrategy(),
+    site: (id: string) => id,
+    input: (key: unknown, def: unknown) => inputLookup(inputs, key, def),
+    colorR,
+    colorG,
+    colorB,
+    colorT,
+    colorNew: compileColorNew,
+    colorRgb,
+    colorFromGradient,
+    colorByName,
+    abs: mathAbs,
+    sign: mathSign,
+    floor: mathFloor,
+    ceil: mathCeil,
+    round: mathRound,
+    sqrt: mathSqrt,
+    exp: mathExp,
+    log: {
+      info(bar: unknown, ...parts: unknown[]) {
+        book.info(logBar(bar), formatLogParts(parts));
+      },
+      warning(bar: unknown, ...parts: unknown[]) {
+        book.warning(logBar(bar), formatLogParts(parts));
+      },
+      error(bar: unknown, ...parts: unknown[]) {
+        book.error(logBar(bar), formatLogParts(parts));
+      },
+      clear() {
+        book.clear();
+      },
+      extras() {
+        return { __logs: book.snapshot() };
+      },
+    },
+    log10: mathLog10,
+    pow: mathPow,
+    min: mathMin,
+    max: mathMax,
+    avg: mathAvg,
+    sin: mathSin,
+    cos: mathCos,
+    tan: mathTan,
+    asin: mathAsin,
+    acos: mathAcos,
+    atan: mathAtan,
+    todegrees: mathToDegrees,
+    toradians: mathToRadians,
+    iff,
+    fixnan: mathFixnan,
+    year: calendarYear,
+    month: calendarMonth,
+    dayofmonth: calendarDayofmonth,
+    hour: calendarHour,
+    minute: calendarMinute,
+    second: calendarSecond,
+    dayofweek: calendarDayofweek,
+    timestamp,
+    weekOfYear,
+    timeTradingDay,
+    timeframeInSeconds,
+    strLength,
+    strContains,
+    strStartsWith,
+    strEndsWith,
+    strLower,
+    strUpper,
+    strReplace,
+    strSubstring,
+    strToNumber,
+    strTrim,
+    strFormat,
+    strFormatTime,
+    tostring: strTostring,
+    str: {
+      length: strLength,
+      contains: strContains,
+      starts_with: strStartsWith,
+      ends_with: strEndsWith,
+      lower: strLower,
+      upper: strUpper,
+      replace: strReplace,
+      substring: strSubstring,
+      tonumber: strToNumber,
+      trim: strTrim,
+      tostring: strTostring,
+      format: strFormat,
+      format_time: strFormatTime,
+    },
+    hold,
+    array: compileArray,
+    map: compileMap,
+    matrix: compileMatrix,
+    draw: createCompileDraw(),
+    udtNew,
+    udtGet,
+    udtSet,
+    udtRegister,
+    currencyRate: resolveCurrencyRate,
+    runtimeError(msg: unknown): never {
+      throw new Error(String(msg));
+    },
+  };
+}
+
+/** Pine `color.new(color, transp)` — first arg is a color, not r,g,b. */
+function compileColorNew(color: unknown, transp?: unknown) {
+  const parsed = asColor(color);
+  if (!parsed) return null;
+  const t = typeof transp === "number" && Number.isFinite(transp) ? transp : undefined;
+  return colorNew(parsed.r, parsed.g, parsed.b, t);
+}
+
+/** Override `def` when `inputs` has `key` or `String(key)`. */
+function inputLookup(
+  inputs: CompileHelperInputs | undefined,
+  key: unknown,
+  def: unknown,
+): unknown {
+  if (inputs == null) return def;
+  if (hasInput(inputs, key)) return inputs[key as string];
+  const asStr = String(key);
+  if (hasInput(inputs, asStr)) return inputs[asStr];
+  return def;
+}
+
+function hasInput(inputs: CompileHelperInputs, key: unknown): boolean {
+  return (
+    (typeof key === "string" || typeof key === "number") &&
+    Object.prototype.hasOwnProperty.call(inputs, key)
+  );
+}
+
+/** Pine v4 `iff`: na cond → na; 0 / false → else; else then. */
+function iff(cond: unknown, thenV: unknown, elseV: unknown): unknown {
+  if (typeof cond === "boolean") return cond ? thenV : elseV;
+  return mathIff(cond as number | null, thenV as number | null, elseV as number | null);
+}
+
+function NA_FN(v?: unknown): number | null {
+  if (arguments.length === 0) return null;
+  return isNaCell(v) ? 1 : 0;
+}
+
+/** Unix-ms → UTC calendar part. na / non-finite time → null. */
+function utcPart(t: unknown, key: keyof UtcParts): number | null {
+  if (typeof t !== "number" || !Number.isFinite(t)) return null;
+  return utcPartsFromMs(t)[key];
+}
+
+function calendarYear(t: unknown): number | null {
+  return utcPart(t, "year");
+}
+
+function calendarMonth(t: unknown): number | null {
+  return utcPart(t, "month");
+}
+
+function calendarDayofmonth(t: unknown): number | null {
+  return utcPart(t, "dayofmonth");
+}
+
+function calendarHour(t: unknown): number | null {
+  return utcPart(t, "hour");
+}
+
+function calendarMinute(t: unknown): number | null {
+  return utcPart(t, "minute");
+}
+
+function calendarSecond(t: unknown): number | null {
+  return utcPart(t, "second");
+}
+
+function calendarDayofweek(t: unknown): number | null {
+  return utcPart(t, "dayofweek");
+}
+
+function logBar(bar: unknown): number {
+  return typeof bar === "number" && Number.isFinite(bar) ? bar : 0;
+}

package/src/runtime/compile/strategy.ts

@@ -0,0 +1,169 @@
+/**
+ * Copyright (C) 2024-2026 jango_blockchained
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * Object-mode compile broker. Python analog: CompileStrategyBroker.
+ * Injected as `__h.strategy`. Wraps StrategyBook (fills + ledger + risk).
+ */
+import {
+  StrategyBook,
+  type BrokerSettings,
+  type PlaceEntryOpts,
+  type StrategyDirection,
+  type StrategyEvent,
+  type StrategySummary,
+} from "../strategy.ts";
+
+function asDir(v: unknown): StrategyDirection | number | string {
+  if (v == null) return "long";
+  if (v === 1 || v === "1" || v === "long" || v === "strategy.long" || v === "buy") return "long";
+  if (v === -1 || v === "-1" || v === "short" || v === "strategy.short" || v === "sell") return "short";
+  return String(v);
+}
+
+function num(v: unknown, fallback: number): number {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (typeof v === "string" && v !== "") {
+    const n = Number(v);
+    if (Number.isFinite(n)) return n;
+  }
+  return fallback;
+}
+
+function str(v: unknown, fallback = ""): string {
+  if (v == null) return fallback;
+  return String(v);
+}
+
+export class CompileStrategy {
+  readonly book: StrategyBook;
+  private bar = 0;
+  private mark = 0;
+  private time = 0;
+
+  constructor(settings?: BrokerSettings) {
+    this.book = new StrategyBook(settings);
+  }
+
+  beginBar(
+    bar: unknown,
+    open: unknown,
+    high: unknown,
+    low: unknown,
+    close: unknown,
+    time?: unknown,
+  ): void {
+    this.bar = num(bar, 0);
+    this.mark = num(close, 0);
+    this.time = time == null ? this.bar : num(time, this.bar);
+    const ohlc = {
+      open: num(open, this.mark),
+      high: num(high, this.mark),
+      low: num(low, this.mark),
+      close: this.mark,
+    };
+    this.book.processPending(this.bar, ohlc);
+    this.book.markOpenTrades(ohlc.high, ohlc.low, ohlc.close);
+  }
+
+  entry(id?: unknown, direction?: unknown, qty?: unknown, opts?: PlaceEntryOpts): void {
+    const q = qty == null ? 1 : num(qty, 1);
+    this.book.placeEntry(this.bar, str(id, "entry"), asDir(direction), q, {
+      price: opts?.price ?? this.mark,
+      time: opts?.time ?? this.time,
+      limit: opts?.limit,
+      stop: opts?.stop,
+      comment: opts?.comment,
+      oca_name: opts?.oca_name,
+      oca_type: opts?.oca_type,
+    });
+  }
+
+  close(id?: unknown, _qty?: unknown): void {
+    this.book.fillClose(this.bar, str(id, ""), this.mark, { time: this.time });
+  }
+
+  close_all(_comment?: unknown): void {
+    this.book.closeAll(this.bar, this.mark);
+  }
+
+  order(id?: unknown, direction?: unknown, qty?: unknown, opts?: PlaceEntryOpts): void {
+    this.entry(id, direction, qty, opts);
+  }
+
+  cancel(id?: unknown): void {
+    this.book.cancel(this.bar, str(id, ""));
+  }
+
+  cancel_all(): void {
+    this.book.cancelAll(this.bar);
+  }
+
+  exit(from_entry?: unknown, _qty?: unknown): void {
+    this.book.fillClose(this.bar, str(from_entry, ""), this.mark, { time: this.time });
+  }
+
+  position_size(): number {
+    return this.book.position.qty;
+  }
+
+  netprofit(): number {
+    return this.book.realizedPnl;
+  }
+
+  equity(): number {
+    return this.book.equity(this.mark);
+  }
+
+  openprofit(): number {
+    const q = this.book.position.qty;
+    const avg = this.book.position.avgPrice;
+    if (q === 0 || avg == null || !Number.isFinite(avg)) return 0;
+    return q * (this.mark - avg);
+  }
+
+  opentrades(): number {
+    return this.book.opentrades;
+  }
+
+  closedtrades(): number {
+    return this.book.closedtrades;
+  }
+
+  risk_allow_entry_in(value?: unknown): void {
+    this.book.riskAllowEntryIn(value);
+  }
+
+  risk_max_position_size(percent?: unknown): void {
+    this.book.riskMaxPositionSize(percent);
+  }
+
+  risk_max_drawdown(value?: unknown, type?: unknown): void {
+    this.book.riskMaxDrawdown(value, type);
+  }
+
+  extras(): CompileStrategyExtras {
+    return {
+      __events: this.book.events.slice(),
+      __fills: this.book.fills.slice(),
+      __position_size: this.book.position.qty,
+      __netprofit: this.book.realizedPnl,
+      __equity: this.book.equity(this.mark),
+      __strategy: this.book.summary(this.mark),
+    };
+  }
+}
+
+export interface CompileStrategyExtras {
+  __events: StrategyEvent[];
+  __fills: StrategyBook["fills"];
+  __position_size: number;
+  __netprofit: number;
+  __equity: number;
+  __strategy: StrategySummary;
+}
+
+export function createCompileStrategy(settings?: BrokerSettings): CompileStrategy {
+  return new CompileStrategy(settings);
+}