@hoox-sh/pynets 0.8.0 → 0.10.0

package/src/runtime/matrix.ts

@@ -8,6 +8,7 @@
  */
 
 import { UdtInstance } from "./udt.ts";
+import { cloneValue } from "./clone.ts";
 
 export type Cell = number | null;
 
@@ -564,6 +565,30 @@ export class PineMatrix {
     }
   }
 
+  /** Deep clone (realtime tick snapshots). */
+  clone(): PineMatrix {
+    const out = new PineMatrix(this.nRows, this.nCols);
+    out.restoreContents(this.snapshotContents());
+    return out;
+  }
+
+  /** Deep-cloned grid + dims for realtime tick rollback. */
+  snapshotContents(): { cells: unknown[][]; nRows: number; nCols: number } {
+    return {
+      cells: this.cells.map((row) => row.map(cloneValue)),
+      nRows: this.nRows,
+      nCols: this.nCols,
+    };
+  }
+
+  /** Replace grid + dims with clones of `snap` — same instance for aliases. */
+  restoreContents(snap: { cells: unknown[][]; nRows: number; nCols: number }): void {
+    this.cells.length = 0;
+    for (const row of snap.cells) this.cells.push(row.map(cloneValue));
+    this.nRows = snap.nRows;
+    this.nCols = snap.nCols;
+  }
+
   transpose(): PineMatrix {
     const t = new PineMatrix(this.nCols, this.nRows);
     for (let i = 0; i < this.nRows; i++) {

package/src/runtime/series.ts

@@ -21,6 +21,12 @@ export class PineSeries {
     else this.data[this.data.length - 1] = value;
   }
 
+  /** Drop cells beyond `len` (realtime tick rollback). No-op when shorter. */
+  truncate(len: number): void {
+    if (len < 0) return;
+    if (this.data.length > len) this.data.length = len;
+  }
+
   get current(): Cell {
     return this.data.length === 0 ? NA : this.data[this.data.length - 1]!;
   }

package/src/runtime/strategy.ts

@@ -11,6 +11,8 @@
  * fillEntry from flat / reverse leftover opens a trade; flatten moves it to closed.
  */
 
+import { cloneValue } from "./clone.ts";
+
 export type StrategyDirection = "long" | "short";
 /** `strategy(..., avg_price_model=)` — stock FIFO reweight / sticky futures AEP. */
 export type AvgPriceModel = "stock" | "futures" | "inverse";
@@ -441,6 +443,36 @@ export class StrategyBook {
     if (settings) this.applyDeclSettings(settings);
   }
 
+  /**
+   * Snapshot all broker state (Python `strategy_state.snapshot()` analog)
+   * for realtime tick rollback: events, position, fills, pending orders,
+   * trades, and every counter.
+   */
+  snapshot(): Record<string, unknown> {
+    const out: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(this as unknown as Record<string, unknown>)) {
+      if (typeof value === "function") continue;
+      out[key] = cloneValue(value);
+    }
+    return out;
+  }
+
+  /** Restore from `snapshot()` — arrays refill in place so aliases keep identity. */
+  restore(snap: Record<string, unknown>): void {
+    const self = this as unknown as Record<string, unknown>;
+    for (const [key, value] of Object.entries(snap)) {
+      const live = self[key];
+      if (Array.isArray(live)) {
+        live.length = 0;
+        for (const item of value as unknown[]) live.push(cloneValue(item));
+      } else if (live !== null && typeof live === "object" && value !== null && typeof value === "object") {
+        Object.assign(live, value);
+      } else {
+        self[key] = cloneValue(value);
+      }
+    }
+  }
+
   /** Margin locked in open trades: sum(|entry * size|) / leverage (Python `capital_held`). */
   capitalHeld(): number {
     let notional = 0;

package/src/runtime/ta.ts

@@ -9,6 +9,7 @@
 export type Cell = number | null;
 
 import { PineArray } from "./array.ts";
+import { cloneValue } from "./clone.ts";
 
 interface SmaState {
   period: number;
@@ -602,6 +603,33 @@ export class TaEngine {
   private readonly momentumFilterSites = new Map<string, { momentum: Cell[]; volume: Cell[] }>();
   private readonly volatilityRegimeSites = new Map<string, Cell[]>();
 
+  /**
+   * Snapshot every per-site window (Python `_snapshot_ta_state`).
+   * Intermediate realtime ticks push one sample per call site; without
+   * rollback the same bar would be counted N times.
+   */
+  snapshot(): Array<[string, Map<string, unknown>]> {
+    const out: Array<[string, Map<string, unknown>]> = [];
+    for (const [key, value] of Object.entries(this as unknown as Record<string, unknown>)) {
+      if (!(value instanceof Map)) continue;
+      const copy = new Map<string, unknown>();
+      for (const [site, state] of value) copy.set(site, cloneValue(state));
+      out.push([key, copy]);
+    }
+    return out;
+  }
+
+  /** Copy-on-restore (Python `_restore_ta_state`); never throws. */
+  restore(snap: Array<[string, Map<string, unknown>]>): void {
+    const self = this as unknown as Record<string, unknown>;
+    for (const [key, copy] of snap) {
+      const live = self[key];
+      if (!(live instanceof Map)) continue;
+      live.clear();
+      for (const [site, state] of copy) live.set(site, cloneValue(state));
+    }
+  }
+
   sma(site: string, source: Cell, period: number): Cell {
     const n = pinePeriod(period);
     if (n === null) return null;

package/src/runtime/udt.ts

@@ -7,6 +7,8 @@
  * remain the source of truth — interpret registers TypeDef / EnumDef later.
  */
 
+import { cloneValue } from "./clone.ts";
+
 export type UdtField = { name: string; default: unknown };
 
 /** Stored method; `body` is opaque (interpret owns FunctionDef). */
@@ -83,6 +85,26 @@ export class UdtInstance {
   getMethod(name: string): UdtMethod | undefined {
     return this.type.getMethod(name);
   }
+
+  /** Deep clone (realtime tick snapshots). */
+  clone(): UdtInstance {
+    const out = new UdtInstance(this.type);
+    out.restoreContents(this.snapshotContents());
+    return out;
+  }
+
+  /** Deep-cloned field values for realtime tick rollback. */
+  snapshotContents(): Array<[string, unknown]> {
+    const out: Array<[string, unknown]> = [];
+    for (const [k, v] of this.values) out.push([k, cloneValue(v)]);
+    return out;
+  }
+
+  /** Replace fields with clones of `snap` — same instance for aliases. */
+  restoreContents(snap: Array<[string, unknown]>): void {
+    this.values.clear();
+    for (const [k, v] of snap) this.values.set(k, cloneValue(v));
+  }
 }
 
 export class EnumMember {