@hoox-sh/pynets 0.2.0 → 0.4.0

package/src/runtime/compile/runtime.ts

@@ -32,6 +32,7 @@ import {
   mathMin,
   mathPow,
   mathRound,
+  mathRoundToMintick,
   mathSign,
   mathSin,
   mathSqrt,
@@ -58,7 +59,8 @@ 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 { TickerId } from "../ticker.ts";
+import { timeframeInSeconds, timeframePeriodChanged } from "../timeframe.ts";
 import { compileArray, compileMap, compileMatrix } from "./collections.ts";
 import { createCompileDraw } from "./draw.ts";
 import {
@@ -81,6 +83,7 @@ import {
   safeNeg,
   safeSub,
 } from "./helpers.ts";
+import { isStrategyCashAmount } from "../strategy.ts";
 import { createCompileStrategy } from "./strategy.ts";
 import { udtGet, udtNew, udtRegister, udtSet } from "./udt_runtime.ts";
 
@@ -94,10 +97,17 @@ export function createCompileHelpers(opts?: CompileHelperOpts) {
   const ta = new TaEngine();
   const inputs = opts?.inputs;
   const book = new LogBook();
+  // Python `timeframe_in_seconds` defaults None / "" to "D" (daily, 86400)
+  // before parsing — builtins/timeframe.py:189-190. The shared helper in
+  // timeframe.ts maps na / empty → null, so compile wraps it here to match.
+  const timeframeInSecondsOrDaily = (p: string | null): number | null =>
+    timeframeInSeconds(p == null || p === "" ? "D" : p);
   return {
     na: NA_FN,
     nz,
     naNum,
+    plotNum,
+    timenow,
     isNa: isNaCell,
     eq: pineEq,
     ne: pineNe,
@@ -174,7 +184,11 @@ export function createCompileHelpers(opts?: CompileHelperOpts) {
     timestamp,
     weekOfYear,
     timeTradingDay,
-    timeframeInSeconds,
+    timeframeInSeconds: timeframeInSecondsOrDaily,
+    timeframeChange,
+    timeClose,
+    roundToMintick,
+    syminfoPrefix,
     strLength,
     strContains,
     strStartsWith,
@@ -253,6 +267,23 @@ function iff(cond: unknown, thenV: unknown, elseV: unknown): unknown {
   return mathIff(cond as number | null, thenV as number | null, elseV as number | null);
 }
 
+/** Plot cell: tagged `strategy.cash` unwraps to its number (interpret `unwrap`). */
+function plotNum(v: unknown): number | null {
+  if (isStrategyCashAmount(v)) return Number.isFinite(v.value) ? v.value : null;
+  return naNum(v);
+}
+
+/**
+ * Dataset last-bar time on every bar. Interpret `beginBar` stores that on
+ * `ctx.timenow` (host seed is overwritten). Not wall-clock, not current bar.
+ */
+function timenow(timeArr: unknown): number {
+  if (!Array.isArray(timeArr) || timeArr.length === 0) return 0;
+  const last = timeArr[timeArr.length - 1];
+  if (typeof last === "number" && Number.isFinite(last)) return last;
+  return (timeArr.length - 1) * 60_000;
+}
+
 function NA_FN(v?: unknown): number | null {
   if (arguments.length === 0) return null;
   return isNaCell(v) ? 1 : 0;
@@ -295,3 +326,52 @@ function calendarDayofweek(t: unknown): number | null {
 function logBar(bar: unknown): number {
   return typeof bar === "number" && Number.isFinite(bar) ? bar : 0;
 }
+
+/** `timeframe.change`: bar 0 is a new period; empty / unknown tf → false. */
+function timeframeChange(tf: unknown, curr: unknown, prev: unknown, barIndex: unknown): number {
+  const s =
+    typeof tf === "string"
+      ? tf
+      : typeof tf === "number" && Number.isFinite(tf)
+        ? String(tf)
+        : null;
+  if (s == null || s.trim() === "") return 0;
+  if (typeof curr !== "number" || !Number.isFinite(curr)) return 0;
+  const idx = typeof barIndex === "number" && Number.isFinite(barIndex) ? barIndex : null;
+  return timeframePeriodChanged(curr, prev, s, idx) ? 1 : 0;
+}
+
+/**
+ * Next bar open, last bar `time + 86400000`. `0` next-open counts as missing
+ * (interpret beginBar). Compile has no per-bar `time_close` column.
+ */
+function timeClose(barIdx: unknown, timeArr: unknown): number {
+  const i = typeof barIdx === "number" && Number.isFinite(barIdx) ? Math.trunc(barIdx) : 0;
+  const arr = Array.isArray(timeArr) ? (timeArr as Array<number | null | undefined>) : [];
+  const t = arr[i];
+  const tNum = typeof t === "number" && Number.isFinite(t) ? t : 0;
+  if (i + 1 < arr.length) {
+    const next = arr[i + 1] ?? 0;
+    return next !== 0 ? next : tNum;
+  }
+  return Math.trunc(tNum) + 86_400_000;
+}
+
+function roundToMintick(x: unknown): number | null {
+  return mathRoundToMintick(naNum(x), 0.01);
+}
+
+/** Python `split_symbol` / `extract_prefix`: text before the first `:`, else `""`. */
+function extractPrefix(symbol: string): string {
+  const s = symbol.trim();
+  const i = s.indexOf(":");
+  return i < 0 ? "" : s.slice(0, i);
+}
+
+function syminfoPrefix(tickerid?: unknown): string {
+  if (arguments.length === 0 || tickerid === undefined) return extractPrefix("SYMBOL");
+  if (tickerid instanceof TickerId) return extractPrefix(tickerid.symbol);
+  if (typeof tickerid === "string") return extractPrefix(tickerid);
+  if (typeof tickerid === "number" && Number.isFinite(tickerid)) return extractPrefix(String(tickerid));
+  return "";
+}

package/src/runtime/compile/strategy.ts

@@ -6,13 +6,19 @@
  * Injected as `__h.strategy`. Wraps StrategyBook (fills + ledger + risk).
  */
 import {
+  isStrategyCashAmount,
+  strategyCashAmount,
   StrategyBook,
+  type BarOhlc,
   type BrokerSettings,
   type PlaceEntryOpts,
+  type PlaceExitOpts,
+  type StrategyCashAmount,
   type StrategyDirection,
   type StrategyEvent,
   type StrategySummary,
 } from "../strategy.ts";
+import { naNum } from "./helpers.ts";
 
 function asDir(v: unknown): StrategyDirection | number | string {
   if (v == null) return "long";
@@ -36,16 +42,72 @@ function str(v: unknown, fallback = ""): string {
   return String(v);
 }
 
+function optNum(v: unknown): number | null {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  return null;
+}
+
+function asExitOpts(v: unknown): PlaceExitOpts {
+  if (v == null || typeof v !== "object" || Array.isArray(v)) return {};
+  const rec = v as Record<string, unknown>;
+  return {
+    from_entry: rec.from_entry == null || rec.from_entry === "" ? null : String(rec.from_entry),
+    qty: optNum(rec.qty),
+    qty_percent: optNum(rec.qty_percent),
+    profit: optNum(rec.profit),
+    limit: optNum(rec.limit),
+    loss: optNum(rec.loss),
+    stop: optNum(rec.stop),
+    trail_price: optNum(rec.trail_price),
+    trail_points: optNum(rec.trail_points),
+    trail_offset: optNum(rec.trail_offset),
+    comment: rec.comment == null ? undefined : String(rec.comment),
+  };
+}
+
 export class CompileStrategy {
   readonly book: StrategyBook;
   private bar = 0;
   private mark = 0;
   private time = 0;
+  private ohlc: BarOhlc = {};
 
   constructor(settings?: BrokerSettings) {
     this.book = new StrategyBook(settings);
   }
 
+  /** Apply `strategy(...)` declaration kwargs (every bar, same as interpret). */
+  configure(settings?: unknown): void {
+    if (settings == null || typeof settings !== "object" || Array.isArray(settings)) return;
+    const rec = settings as Record<string, unknown>;
+    const broker: BrokerSettings = {};
+    const commission = optNum(rec.commission);
+    if (commission != null) broker.commission = commission;
+    const slippage = optNum(rec.slippage);
+    if (slippage != null) broker.slippage = slippage;
+    if (rec.pyramiding !== undefined) {
+      const pyr = optNum(rec.pyramiding);
+      broker.pyramiding = pyr == null ? undefined : Math.trunc(pyr);
+    }
+    if (typeof rec.avg_price_model === "string") broker.avg_price_model = rec.avg_price_model;
+    const leverage = optNum(rec.leverage);
+    if (leverage != null) broker.leverage = leverage;
+    const ml = optNum(rec.margin_long);
+    if (ml != null) broker.margin_long = ml;
+    const ms = optNum(rec.margin_short);
+    if (ms != null) broker.margin_short = ms;
+    // String sentinel or tagged free-cash (`strategy.cash`) both select cash sizing.
+    if (typeof rec.default_qty_type === "string" || isStrategyCashAmount(rec.default_qty_type)) {
+      broker.default_qty_type = rec.default_qty_type;
+    }
+    const dqv = optNum(rec.default_qty_value);
+    if (dqv != null) broker.default_qty_value = dqv;
+    if (typeof rec.currency === "string" && rec.currency !== "") broker.currency = rec.currency;
+    if (Object.keys(broker).length) this.book.configure(broker);
+    const capital = optNum(rec.initial_capital);
+    if (capital != null) this.book.initialCapital = capital;
+  }
+
   beginBar(
     bar: unknown,
     open: unknown,
@@ -63,14 +125,16 @@ export class CompileStrategy {
       low: num(low, this.mark),
       close: this.mark,
     };
+    this.ohlc = ohlc;
     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);
+    const fillPrice = opts?.price ?? this.mark;
+    const q = qty == null ? this.book.resolveDefaultQty(fillPrice) : num(qty, 1);
     this.book.placeEntry(this.bar, str(id, "entry"), asDir(direction), q, {
-      price: opts?.price ?? this.mark,
+      price: fillPrice,
       time: opts?.time ?? this.time,
       limit: opts?.limit,
       stop: opts?.stop,
@@ -80,8 +144,11 @@ export class CompileStrategy {
     });
   }
 
-  close(id?: unknown, _qty?: unknown): void {
-    this.book.fillClose(this.bar, str(id, ""), this.mark, { time: this.time });
+  close(id?: unknown, qty?: unknown): void {
+    this.book.fillClose(this.bar, str(id, ""), this.mark, {
+      time: this.time,
+      qty: optNum(qty),
+    });
   }
 
   close_all(_comment?: unknown): void {
@@ -100,8 +167,14 @@ export class CompileStrategy {
     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 });
+  exit(id?: unknown, opts?: unknown): void {
+    const parsed = asExitOpts(opts);
+    this.book.placeExit(this.bar, str(id, "exit"), {
+      ...parsed,
+      price: this.mark,
+      time: this.time,
+      ohlc: this.ohlc,
+    });
   }
 
   position_size(): number {
@@ -131,6 +204,266 @@ export class CompileStrategy {
     return this.book.closedtrades;
   }
 
+  leverage(): number {
+    return this.book.leverage;
+  }
+
+  margin_liquidation_price(): number | null {
+    return this.book.marginLiquidationPrice();
+  }
+
+  position_avg_price(): number | null {
+    return this.book.position.avgPrice;
+  }
+
+  initial_capital(): number {
+    return this.book.initialCapital;
+  }
+
+  /** Free cash tagged so `default_qty_type=strategy.cash` still selects cash sizing. */
+  cash(): StrategyCashAmount {
+    return strategyCashAmount(this.book.cash(this.mark));
+  }
+
+  position_entry_name(): string {
+    return this.book.position_entry_name;
+  }
+
+  account_currency(): string {
+    return this.book.account_currency;
+  }
+
+  /** Zero-arg form is `percent_equity=100` (interpret `strategy.default_entry_qty`). */
+  default_entry_qty(percent?: unknown): number | null {
+    const pct = arguments.length === 0 || percent === undefined ? 100 : naNum(percent);
+    if (pct == null) return null;
+    return (this.book.initialCapital * (pct / 100)) / 100;
+  }
+
+  /** Identity FX stub. Missing arg → 1; na / non-finite → na. */
+  convert_to(value?: unknown): number | null {
+    if (arguments.length === 0 || value === undefined) return 1;
+    return naNum(value);
+  }
+
+  max_contracts_held_all(): number {
+    return this.book.maxContractsHeldAll();
+  }
+
+  max_contracts_held_long(): number {
+    return this.book.maxContractsHeldLong();
+  }
+
+  max_contracts_held_short(): number {
+    return this.book.maxContractsHeldShort();
+  }
+
+  capital_held(): number {
+    return this.book.capitalHeld();
+  }
+
+  closedtrades_first_index(): number {
+    return this.book.closedtrades_first_index;
+  }
+
+  wintrades(): number {
+    return this.book.wintrades;
+  }
+
+  losstrades(): number {
+    return this.book.losstrades;
+  }
+
+  eventrades(): number {
+    return this.book.eventrades;
+  }
+
+  grossprofit(): number {
+    return this.book.grossprofit;
+  }
+
+  grossloss(): number {
+    return this.book.grossloss;
+  }
+
+  avg_trade(): number {
+    return this.book.avgTrade();
+  }
+
+  avg_winning_trade(): number {
+    return this.book.avgWinningTrade();
+  }
+
+  avg_losing_trade(): number {
+    return this.book.avgLosingTrade();
+  }
+
+  netprofit_percent(): number {
+    return this.book.netprofitPercent(this.mark);
+  }
+
+  openprofit_percent(): number {
+    return this.book.openprofitPercent(this.mark);
+  }
+
+  grossprofit_percent(): number {
+    return this.book.grossprofitPercent();
+  }
+
+  grossloss_percent(): number {
+    return this.book.grosslossPercent();
+  }
+
+  avg_trade_percent(): number {
+    return this.book.avgTradePercent();
+  }
+
+  avg_winning_trade_percent(): number {
+    return this.book.avgWinningTradePercent();
+  }
+
+  avg_losing_trade_percent(): number {
+    return this.book.avgLosingTradePercent();
+  }
+
+  max_drawdown(): number {
+    return this.book.maxDrawdown();
+  }
+
+  max_drawdown_percent(): number {
+    return this.book.maxDrawdownPercent();
+  }
+
+  max_runup(): number {
+    return this.book.maxRunup();
+  }
+
+  max_runup_percent(): number {
+    return this.book.maxRunupPercent();
+  }
+
+  percent_profitable(): number {
+    return this.book.percentProfitable();
+  }
+
+  winrate(): number {
+    return this.book.percentProfitable();
+  }
+
+  profitfactor(): number {
+    return this.book.profitFactor();
+  }
+
+  profit_factor(): number {
+    return this.book.profitFactor();
+  }
+
+  closedtrades_entry_bar_index(i?: unknown): number {
+    return this.book.closedEntryBar(this.idx(i)) ?? 0;
+  }
+
+  closedtrades_entry_price(i?: unknown): number {
+    return this.book.closedEntryPrice(this.idx(i)) ?? 0;
+  }
+
+  closedtrades_exit_bar_index(i?: unknown): number {
+    return this.book.closedExitBar(this.idx(i)) ?? 0;
+  }
+
+  closedtrades_exit_price(i?: unknown): number {
+    return this.book.closedExitPrice(this.idx(i)) ?? 0;
+  }
+
+  closedtrades_profit(i?: unknown): number {
+    return this.book.closedProfit(this.idx(i)) ?? 0;
+  }
+
+  closedtrades_size(i?: unknown): number {
+    return this.book.closedSize(this.idx(i)) ?? 0;
+  }
+
+  closedtrades_entry_id(i?: unknown): string {
+    return this.book.closedId(this.idx(i)) ?? "";
+  }
+
+  closedtrades_exit_id(i?: unknown): string {
+    return this.book.closedId(this.idx(i)) ?? "";
+  }
+
+  closedtrades_commission(i?: unknown): number {
+    return this.book.closedCommission(this.idx(i)) ?? 0;
+  }
+
+  closedtrades_entry_time(i?: unknown): number {
+    return this.book.closedEntryTime(this.idx(i));
+  }
+
+  closedtrades_exit_time(i?: unknown): number {
+    return this.book.closedExitTime(this.idx(i));
+  }
+
+  closedtrades_entry_comment(i?: unknown): string {
+    return this.book.closedEntryComment(this.idx(i));
+  }
+
+  closedtrades_exit_comment(i?: unknown): string {
+    return this.book.closedExitComment(this.idx(i));
+  }
+
+  closedtrades_max_drawdown(i?: unknown): number {
+    return this.book.closedMaxDrawdown(this.idx(i));
+  }
+
+  closedtrades_max_runup(i?: unknown): number {
+    return this.book.closedMaxRunup(this.idx(i));
+  }
+
+  opentrades_entry_bar_index(i?: unknown): number {
+    return this.book.openEntryBar(this.idx(i)) ?? 0;
+  }
+
+  opentrades_entry_price(i?: unknown): number {
+    return this.book.openEntryPrice(this.idx(i)) ?? 0;
+  }
+
+  opentrades_size(i?: unknown): number {
+    return this.book.openSize(this.idx(i)) ?? 0;
+  }
+
+  opentrades_entry_id(i?: unknown): string {
+    return this.book.openId(this.idx(i)) ?? "";
+  }
+
+  opentrades_profit(i?: unknown): number {
+    return this.book.openProfit(this.idx(i), this.mark) ?? 0;
+  }
+
+  opentrades_entry_time(i?: unknown): number {
+    return this.book.openEntryTime(this.idx(i));
+  }
+
+  opentrades_entry_comment(i?: unknown): string {
+    return this.book.openEntryComment(this.idx(i));
+  }
+
+  opentrades_commission(i?: unknown): number {
+    return this.book.openCommission(this.idx(i));
+  }
+
+  opentrades_max_drawdown(i?: unknown): number {
+    return this.book.openMaxDrawdown(this.idx(i));
+  }
+
+  opentrades_max_runup(i?: unknown): number {
+    return this.book.openMaxRunup(this.idx(i));
+  }
+
+  private idx(i: unknown): number {
+    if (typeof i === "boolean") return i ? 1 : 0;
+    if (typeof i === "number" && Number.isFinite(i)) return Math.trunc(i);
+    return 0;
+  }
+
   risk_allow_entry_in(value?: unknown): void {
     this.book.riskAllowEntryIn(value);
   }

package/src/runtime/compile/types.ts

@@ -58,6 +58,8 @@ export interface EmitCtx {
   usesStrategy: boolean;
   nextSite: number;
   errors: string[];
+  /** `once`-structure fired flags, declared in the bar-loop frame. */
+  onceFlags: string[];
   /** Pine UDF name currently being emitted (null at script scope). */
   currentFunc: string | null;
   /** Formal names of the current UDF. */