openalgo-script 0.2.0 → 0.5.0

package/dist/adapters/codemirror/tooltips.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltips.js","sourceRoot":"","sources":["../../../src/adapters/codemirror/tooltips.ts"],"names":[],"mappings":"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"}

package/dist/core/accounting/analysis.d.ts

@@ -0,0 +1,111 @@
+/**
+ * The trades taken apart: by direction, by extreme, and by run.
+ *
+ * The summary answers what the whole run did. Three questions it cannot answer
+ * are asked here, and each of them is a question about whether the summary
+ * means what it looks like it means.
+ *
+ * **Which side made the money.** A run whose long trades paid for its short
+ * ones reports a healthy net and is two strategies, one of which is losing. The
+ * summary cannot show that, because every figure in it is folded over both
+ * sides at once. Splitting it is not a refinement of the headline number, it is
+ * the first thing that can contradict it.
+ *
+ * **Whether one trade is the result.** A hundred trades and a profit factor of
+ * two reads as an edge until the largest win is the whole of the net. The
+ * expectancy's standard error already says how wide the spread is; the largest
+ * win and the largest loss say where the width came from, which is the part a
+ * reader can act on.
+ *
+ * **What the run of losses was.** The deepest drawdown is a money figure and
+ * the longest one is a bar count, and neither is the number that actually stops
+ * somebody trading a strategy. That number is how many times in a row it was
+ * wrong. It is not derivable from anything in the summary: the same win rate
+ * over the same trades gives a streak of two or a streak of eleven depending on
+ * an ordering the summary folds away.
+ *
+ * ## Every figure here is over closed trades, and that is the whole rule
+ *
+ * An open trade has no net to win or lose by, so it is in none of these counts,
+ * on either side, in no streak and in no extreme. `statistics.ts` has three
+ * different answers to which trades a figure is counted over, because a summary
+ * carries a capital figure and a bar count that are facts about the run rather
+ * than about its trades. Nothing here is a fact about the run, so there is one
+ * answer, and a reader can hold it.
+ *
+ * The consequence worth stating: `longCount + shortCount` is `tradeCount` and
+ * not the length of the list folded. A run holding an open position reports
+ * fewer trades here than it has, and the summary's `openTradeCount` is where
+ * the difference is accounted for.
+ */
+import type { Money } from './shapes.js';
+import type { Trade } from './trades.js';
+/** One direction's own figures, folded over that side's closed trades. */
+export interface SideAnalysis {
+    readonly count: number;
+    readonly wins: number;
+    readonly losses: number;
+    /** Exactly zero net, counted in neither half, as in the summary. */
+    readonly scratches: number;
+    /** Net after charges, which is the figure the sides are compared on. */
+    readonly netProfit: Money;
+    /** `wins / (wins + losses)`, null where this side decided nothing. */
+    readonly winRate: number | null;
+}
+/**
+ * The trades by direction, by extreme and by run.
+ *
+ * `long` and `short` partition the closed trades, so their counts sum to the
+ * summary's `tradeCount` and their nets sum to its `netProfit`. That is
+ * asserted rather than assumed, because a partition that stops partitioning is
+ * the defect this shape exists to make visible and it would otherwise show up
+ * as two panels that quietly disagree.
+ */
+export interface TradeAnalysis {
+    readonly long: SideAnalysis;
+    readonly short: SideAnalysis;
+    /**
+     * The best closed trade's net, zero where none closed and zero where every
+     * closed trade lost.
+     *
+     * Zero rather than null, and it is the one place here that is worth arguing
+     * about. A run whose every trade lost has no winning trade to name, and null
+     * would say so. It reports zero because the figure is read beside
+     * `largestLoss` and against `netProfit`, and a null in a column of money
+     * forces every reader of the report to handle a case that means "nothing
+     * won", which is what zero already means in this column.
+     */
+    readonly largestWin: Money;
+    /** The worst closed trade's net as a positive magnitude, zero where none lost. */
+    readonly largestLoss: Money;
+    /**
+     * The longest run of consecutive winning closed trades, in the order they
+     * closed.
+     *
+     * In the order they closed, and not the order they opened, because that is
+     * the order the account experienced them in and the streak is a fact about
+     * what the account experienced. The two orders differ whenever a trade is
+     * held across another one's whole life, which is every scaling strategy.
+     */
+    readonly maxConsecutiveWins: number;
+    /** The same, for losses. */
+    readonly maxConsecutiveLosses: number;
+}
+/**
+ * One pass over the closed trades, in closing order.
+ *
+ * The list arrives in opening order, which is what the equity fold needs and
+ * what `tradesOf` produces. The streaks need closing order, so the closed
+ * trades are ordered here rather than anywhere else: reordering the list the
+ * caller holds would change the equity curve, and taking a second list in
+ * opening order and calling its streaks correct would be the defect this
+ * function is supposed to have caught.
+ *
+ * A trade whose net is exactly zero is a scratch, which is the summary's rule
+ * and is applied here for the same reason. A scratch **breaks** a streak
+ * without extending either one: a strategy that went right, flat, right was not
+ * right twice running, and counting the flat trade as either would make the
+ * streak a figure that depends on a rounding at the last digit.
+ */
+export declare function analysisOf(trades: readonly Trade[]): TradeAnalysis;
+//# sourceMappingURL=analysis.d.ts.map

package/dist/core/accounting/analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.d.ts","sourceRoot":"","sources":["../../../src/core/accounting/analysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;IAC3B,kFAAkF;IAClF,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;IAC5B;;;;;;;;OAQG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,4BAA4B;IAC5B,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;CACvC;AA2BD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,aAAa,CAiDlE"}

package/dist/core/accounting/analysis.js

@@ -0,0 +1,123 @@
+/**
+ * The trades taken apart: by direction, by extreme, and by run.
+ *
+ * The summary answers what the whole run did. Three questions it cannot answer
+ * are asked here, and each of them is a question about whether the summary
+ * means what it looks like it means.
+ *
+ * **Which side made the money.** A run whose long trades paid for its short
+ * ones reports a healthy net and is two strategies, one of which is losing. The
+ * summary cannot show that, because every figure in it is folded over both
+ * sides at once. Splitting it is not a refinement of the headline number, it is
+ * the first thing that can contradict it.
+ *
+ * **Whether one trade is the result.** A hundred trades and a profit factor of
+ * two reads as an edge until the largest win is the whole of the net. The
+ * expectancy's standard error already says how wide the spread is; the largest
+ * win and the largest loss say where the width came from, which is the part a
+ * reader can act on.
+ *
+ * **What the run of losses was.** The deepest drawdown is a money figure and
+ * the longest one is a bar count, and neither is the number that actually stops
+ * somebody trading a strategy. That number is how many times in a row it was
+ * wrong. It is not derivable from anything in the summary: the same win rate
+ * over the same trades gives a streak of two or a streak of eleven depending on
+ * an ordering the summary folds away.
+ *
+ * ## Every figure here is over closed trades, and that is the whole rule
+ *
+ * An open trade has no net to win or lose by, so it is in none of these counts,
+ * on either side, in no streak and in no extreme. `statistics.ts` has three
+ * different answers to which trades a figure is counted over, because a summary
+ * carries a capital figure and a bar count that are facts about the run rather
+ * than about its trades. Nothing here is a fact about the run, so there is one
+ * answer, and a reader can hold it.
+ *
+ * The consequence worth stating: `longCount + shortCount` is `tradeCount` and
+ * not the length of the list folded. A run holding an open position reports
+ * fewer trades here than it has, and the summary's `openTradeCount` is where
+ * the difference is accounted for.
+ */
+function emptySide() {
+    return { count: 0, wins: 0, losses: 0, scratches: 0, netProfit: 0 };
+}
+function sideOf(tally) {
+    const decided = tally.wins + tally.losses;
+    return {
+        count: tally.count,
+        wins: tally.wins,
+        losses: tally.losses,
+        scratches: tally.scratches,
+        netProfit: tally.netProfit,
+        winRate: decided === 0 ? null : tally.wins / decided,
+    };
+}
+/**
+ * One pass over the closed trades, in closing order.
+ *
+ * The list arrives in opening order, which is what the equity fold needs and
+ * what `tradesOf` produces. The streaks need closing order, so the closed
+ * trades are ordered here rather than anywhere else: reordering the list the
+ * caller holds would change the equity curve, and taking a second list in
+ * opening order and calling its streaks correct would be the defect this
+ * function is supposed to have caught.
+ *
+ * A trade whose net is exactly zero is a scratch, which is the summary's rule
+ * and is applied here for the same reason. A scratch **breaks** a streak
+ * without extending either one: a strategy that went right, flat, right was not
+ * right twice running, and counting the flat trade as either would make the
+ * streak a figure that depends on a rounding at the last digit.
+ */
+export function analysisOf(trades) {
+    const long = emptySide();
+    const short = emptySide();
+    let largestWin = 0;
+    let largestLoss = 0;
+    let maxConsecutiveWins = 0;
+    let maxConsecutiveLosses = 0;
+    let winStreak = 0;
+    let lossStreak = 0;
+    const closed = trades.filter((trade) => !trade.isOpen).slice();
+    // A trade closes on a bar, and two can close on the same one. The opening
+    // order breaks the tie, because it is the order the list arrived in and the
+    // only other fact available: a sort that is not total gives two engines two
+    // different streaks from one list of trades.
+    closed.sort((a, b) => (a.closedOnBar ?? 0) - (b.closedOnBar ?? 0) || a.index - b.index);
+    for (const trade of closed) {
+        const side = trade.side === 'long' ? long : short;
+        side.count += 1;
+        side.netProfit += trade.netProfit;
+        if (trade.netProfit > 0) {
+            side.wins += 1;
+            if (trade.netProfit > largestWin)
+                largestWin = trade.netProfit;
+            winStreak += 1;
+            lossStreak = 0;
+            if (winStreak > maxConsecutiveWins)
+                maxConsecutiveWins = winStreak;
+        }
+        else if (trade.netProfit < 0) {
+            side.losses += 1;
+            if (-trade.netProfit > largestLoss)
+                largestLoss = -trade.netProfit;
+            lossStreak += 1;
+            winStreak = 0;
+            if (lossStreak > maxConsecutiveLosses)
+                maxConsecutiveLosses = lossStreak;
+        }
+        else {
+            side.scratches += 1;
+            winStreak = 0;
+            lossStreak = 0;
+        }
+    }
+    return {
+        long: sideOf(long),
+        short: sideOf(short),
+        largestWin,
+        largestLoss,
+        maxConsecutiveWins,
+        maxConsecutiveLosses,
+    };
+}
+//# sourceMappingURL=analysis.js.map

package/dist/core/accounting/analysis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.js","sourceRoot":"","sources":["../../../src/core/accounting/analysis.ts"],"names":[],"mappings":"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"}

package/dist/core/accounting/charges.d.ts

@@ -0,0 +1,136 @@
+import type { Diagnostic } from '../diagnostics/index.js';
+import type { Contract, Money, RecordedFill } from './shapes.js';
+/**
+ * What a line's rate is measured against.
+ *
+ * Four bases cover every stack the documentation describes without naming a
+ * market: a fraction of turnover, money per unit, money per fill, and a
+ * fraction of the lines named before this one, which is the charge on a charge.
+ */
+export type ChargeBase = 'turnover' | 'units' | 'order' | 'charges';
+/**
+ * Which side of the trade a line applies to.
+ *
+ * A transaction tax levied on one side is expressed exactly rather than smeared
+ * across both fills at half the rate, which is what a reader doing it by hand
+ * has to do and what makes their figure disagree with their broker's.
+ */
+export type ChargeSide = 'buy' | 'sell' | 'both';
+/** One line of a schedule, applied to one fill. */
+export interface ChargeLine {
+    /** The platform's own word. */
+    readonly name: string;
+    readonly base: ChargeBase;
+    readonly side: ChargeSide;
+    /**
+     * Fraction for turnover and charges, money per unit for units, money for
+     * order.
+     */
+    readonly rate: number;
+    /** Floor per application. */
+    readonly min: Money | null;
+    /** Cap per application. */
+    readonly max: Money | null;
+    /** Base 'charges' only: names of lines declared before this one. */
+    readonly of: readonly string[];
+}
+/** The whole cost model a run was carried out under. */
+export interface ChargeSchedule {
+    readonly currency: string;
+    readonly digits: number;
+    readonly slippageTicks: number;
+    /** Applied in order, and order is part of the result. */
+    readonly lines: readonly ChargeLine[];
+    /**
+     * Where the schedule came from.
+     *
+     * A schedule derived from the declaration is derived again on replay rather
+     * than stored, because what the program states is stored once, as the
+     * program. A supplied one is the host's choice and travels with the record.
+     */
+    readonly source: 'declaration' | 'supplied';
+}
+/** What one fill was charged, line by line and in total. */
+export interface ChargeBreakdown {
+    readonly lines: readonly {
+        readonly name: string;
+        readonly amount: Money;
+    }[];
+    readonly total: Money;
+}
+/**
+ * What one fill cost, line by line and in total.
+ *
+ * **The lines are the arithmetic and the total is the money.** Each line's
+ * amount is computed in binary64 and left unrounded, and the per-fill total is
+ * rounded once, half to even, to the contract's digits. Rounding each line
+ * would round once per line, and two engines rounding in two places disagree in
+ * the last bit, which is a failed conformance comparison months later on
+ * somebody else's engine. So a reader adding the lines up by hand may land a
+ * fraction of the last digit away from the total, and that is the honest way
+ * round: the total is the figure the report accumulates.
+ *
+ * **Half to even, and not the language's own rounding.** `round()` in the
+ * language is halves away from zero, because a price a trader reads should
+ * agree with what they would write down (`stdlib.md` 8.1). Money folded over
+ * thousands of fills is a different question: away from zero biases every exact
+ * half upward, and half a unit of the last digit per fill is a bias that grows
+ * with the length of the backtest. Two rules, two reasons, both written down.
+ *
+ * **A line that does not apply to this side is not in the breakdown at all.** A
+ * name beside a zero reads as a charge that was levied and came to nothing,
+ * which is not what happened, and a later line levied on that name is levied on
+ * nothing, which is exactly what a tax on one side of the trade does.
+ */
+export declare function chargeFor(schedule: ChargeSchedule, fill: RecordedFill, contract: Contract): ChargeBreakdown;
+/**
+ * The declaration's own cost model, as the one schedule this module evaluates.
+ *
+ * **The declaration is not a second cost engine.** Its three commission
+ * spellings are a schedule of one line: a flat fee is a line charged per fill,
+ * a per unit fee is a line charged per unit, and a percentage is a line charged
+ * on turnover. A second evaluator for the declaration would be the same money
+ * computed two ways, and the day the two disagreed the report and the
+ * platform's own cost panel would both be defensible.
+ *
+ * **A commission of zero is no line at all**, rather than a line charging
+ * nothing. A zero line would put a name in every breakdown, and it would make a
+ * declaration that states no commission indistinguishable from one that states
+ * a commission, which is the distinction a run has to make before it accepts a
+ * schedule from the host as well.
+ *
+ * **A flat fee is charged per fill**, which is the one place `language.md` 13.3
+ * lets a reasonable person read the words two ways: per order, or per completed
+ * round trip. A charge is attributed to the fill that incurred it everywhere in
+ * this module, because that is what attributes it to a trade, so a round trip of
+ * two fills is charged twice.
+ *
+ * The currency and the digit count are parameters because neither is the
+ * declaration's to state: the declaration's currency is a label and is often
+ * left blank, and money rounding is a fact about the contract. A default here
+ * would be this module inventing a rounding rule for somebody else's market.
+ *
+ * `commissionType`'s value set is declared once, in `check/declaration.ts`, and
+ * is not restated here: what is below is a mapping from each spelling to the
+ * line it means. A program reaching this has been checked, so a fourth spelling
+ * cannot arrive, and the spelling that falls through is the declaration's own
+ * default rather than a shape this module made up.
+ */
+export declare function scheduleFromDeclaration(commission: number, commissionType: string, slippage: number, currency: string, digits: number): ChargeSchedule;
+/**
+ * Why this schedule cannot be carried out, or null.
+ *
+ * **Asked before the first bar, and answered once.** Everything here is a fact
+ * about the schedule rather than about any fill, so a run that would produce a
+ * number nobody can explain is refused while nothing has been computed and the
+ * cost of correcting it is one run. The contract is optional because a schedule
+ * is checkable on its own: what it adds is the three questions that need both,
+ * which are the currency the money is in, the digits it is rounded to, and the
+ * tick a slippage in ticks is measured in.
+ *
+ * The first problem found is the one reported. A list of everything wrong with
+ * a schedule reads as a worse schedule than it is, and it is corrected one line
+ * at a time regardless.
+ */
+export declare function scheduleProblem(schedule: ChargeSchedule, contract?: Contract | null): Diagnostic | null;
+//# sourceMappingURL=charges.d.ts.map

package/dist/core/accounting/charges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"charges.d.ts","sourceRoot":"","sources":["../../../src/core/accounting/charges.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAEjD,mDAAmD;AACnD,MAAM,WAAW,UAAU;IACzB,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6BAA6B;IAC7B,QAAQ,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,CAAC;IAC3B,2BAA2B;IAC3B,QAAQ,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,CAAC;IAC3B,oEAAoE;IACpE,QAAQ,CAAC,EAAE,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,wDAAwD;AACxD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,UAAU,CAAC;CAC7C;AAED,4DAA4D;AAC5D,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAA;KAAE,EAAE,CAAC;IAC7E,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB;AAgCD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,QAAQ,GACjB,eAAe,CAcjB;AAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,cAAc,CAQhB;AAcD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,cAAc,EACxB,QAAQ,GAAE,QAAQ,GAAG,IAAW,GAC/B,UAAU,GAAG,IAAI,CAQnB"}