trigerr 0.7.1__tar.gz → 0.7.2__tar.gz

{trigerr-0.7.1/trigerr.egg-info → trigerr-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trigerr
-Version: 0.7.1
+Version: 0.7.2
 Summary: Python tools for quantitative trading research and analysis.
 Author: Anurag Singh Kushwah
 License-Expression: MIT
@@ -31,18 +31,19 @@ Dynamic: license-file
 
 # Trigerr
 
-Trigerr is a Python package for quantitative trading research and analysis.
-It is being developed as an open-source successor to an earlier internal
-package, with an initial focus on dependable offline tools: technical
-indicators, OHLCV utilities, market-structure analysis, P&L calculations,
-reports, and in-memory backtesting.
+Trigerr is a Python package for algorithmic trading — technical indicators,
+OHLCV utilities, market-structure analysis, P&L calculations, reports,
+in-memory backtesting, and network-connected data and order execution
+(historical/live market data, backtest/virtual/live order engines, a
+canonical-AST strategy framework). It is the successor to an earlier internal
+package.
 
 ## Status
 
-Trigerr is in its initial migration phase. The import namespace and packaging
-are ready; the public API is not yet stable. Network-connected data and order
-integrations will be redesigned as optional adapters rather than treated as
-part of the core package.
+Trigerr is at v0.7.1 and in production use on the Trigerr white-label trading
+platform (live, virtual and backtest order flow; live market data over Redis
+Streams). The public API is versioned but still evolving — pin a version in
+production and read the changelog before upgrading.
 
 Trigerr supports Python 3.10 and newer.
 
@@ -76,9 +77,12 @@ Do not use real trading credentials in examples, tests, or committed files.
 
 ## Roadmap
 
-The near-term focus is stabilizing the offline analysis core (indicators,
-utilities, backtesting) and reshaping the network-connected data and order
-integrations into optional adapters.
+Near-term work is on the platform side rather than the SDK's own shape:
+onboarding more brokers to live order execution (Dhan, then Upstox), and
+extending the canonical-AST strategy framework (`trigerr.framework`) to more
+strategy families. See `PLATFORM_TARGET_ARCHITECTURE.md` in the
+`trigerr-trading-strategies` repo for the platform-wide plan this SDK
+implements.
 
 ## License
 

trigerr-0.7.2/README.md

@@ -0,0 +1,58 @@
+# Trigerr
+
+Trigerr is a Python package for algorithmic trading — technical indicators,
+OHLCV utilities, market-structure analysis, P&L calculations, reports,
+in-memory backtesting, and network-connected data and order execution
+(historical/live market data, backtest/virtual/live order engines, a
+canonical-AST strategy framework). It is the successor to an earlier internal
+package.
+
+## Status
+
+Trigerr is at v0.7.1 and in production use on the Trigerr white-label trading
+platform (live, virtual and backtest order flow; live market data over Redis
+Streams). The public API is versioned but still evolving — pin a version in
+production and read the changelog before upgrading.
+
+Trigerr supports Python 3.10 and newer.
+
+## Installation
+
+```bash
+pip install trigerr
+```
+
+For local development from a checkout:
+
+```bash
+pip install -e ".[dev]"
+python -m pytest
+```
+
+## Current configuration API
+
+The existing configuration helpers remain available while the integration
+layer is migrated:
+
+```python
+import trigerr
+
+trigerr.set_api_key("your-api-key")
+trigerr.set_data_url("https://data.example.com/")
+trigerr.set_orders_url("https://orders.example.com/")
+```
+
+Do not use real trading credentials in examples, tests, or committed files.
+
+## Roadmap
+
+Near-term work is on the platform side rather than the SDK's own shape:
+onboarding more brokers to live order execution (Dhan, then Upstox), and
+extending the canonical-AST strategy framework (`trigerr.framework`) to more
+strategy families. See `PLATFORM_TARGET_ARCHITECTURE.md` in the
+`trigerr-trading-strategies` repo for the platform-wide plan this SDK
+implements.
+
+## License
+
+Trigerr is released under the [MIT License](LICENSE).

trigerr-0.7.2/tests/test_bt_orders.py

@@ -0,0 +1,109 @@
+""" The two pieces a backtest stands on: the in-memory state cursor and the bt order document.
+
+A backtest's order must be the vt order — same keys, same stringification, read back through the same
+orders list — because one execution core serves vt, lt and bt. It may differ only where a backtest
+must: stamped from the replayed candle, no database, no alert, no swallowed errors.
+"""
+import datetime
+import types
+
+import pytest
+
+import trigerr.orders.virtual as virtual
+import trigerr.utils as utils
+from trigerr.framework.bt_state import memory_state_cursor
+from trigerr.orders.backtest import place_bt_leg_order
+from trigerr.orders.orders_utils import acquire_exit_mutex, fetch_orders_list, release_exit_mutex, renew_exit_mutex
+
+CANDLE = {"symbol": "NIFTY_50", "close": 101.5, "timestamp": datetime.datetime(2025, 6, 2, 9, 31, 7, 500)}
+ORDER = dict(quantity=5, quantity_left=5, position_type="LONG", transaction_type="BUY", trade_action="ENTRY",
+             user_id="u1", strategy_id="s1", request_id="r1", market="IN", exchange="NSE", venue="XNSE",
+             data_key="UPSTOX:XNSE:NIFTY_50", group_id="r1:2025-06-02:1", leg_key="SPOT", lot_size=1,
+             params={"investment": 100000, "sl_price": 70.0})
+
+
+# ---------------------------------------------------------------- memory_state_cursor
+
+def test_memory_cursor_lists_behave_like_redis_lists():
+    c = memory_state_cursor()
+    assert c.rpush("k", "a") == 1 and c.rpush("k", "b", "c") == 3
+    assert c.lrange("k", 0, -1) == ["a", "b", "c"] and c.lrange("k", 1, 1) == ["b"]
+    assert c.llen("k") == 3 and c.llen("missing") == 0 and c.lrange("missing", 0, -1) == []
+
+
+def test_memory_cursor_strings_and_set_nx():
+    c = memory_state_cursor()
+    assert c.set("m", "t1", nx=True, ex=120) is True
+    assert c.set("m", "t2", nx=True, ex=120) is None          # already held
+    assert c.get("m") == "t1" and c.get("nope") is None
+    assert c.delete("m") == 1 and c.delete("m") == 0
+
+
+def test_memory_cursor_publish_and_expire_are_harmless():
+    c = memory_state_cursor()
+    c.rpush("k", "x")
+    assert c.publish("channel", "msg") == 0 and c.expire("k", 10) is True and c.expire("none", 10) is False
+
+
+def test_exit_mutex_helpers_work_on_the_memory_cursor():
+    c = memory_state_cursor()
+    token = acquire_exit_mutex(c, "r1")
+    assert token and acquire_exit_mutex(c, "r1", wait_s=0) is None     # mutually exclusive
+    renew_exit_mutex(c, "r1", token)
+    release_exit_mutex(c, "r1", "someone-elses-token")                 # must not free it
+    assert acquire_exit_mutex(c, "r1", wait_s=0) is None
+    release_exit_mutex(c, "r1", token)
+    assert acquire_exit_mutex(c, "r1", wait_s=0)
+
+
+# ---------------------------------------------------------------- place_bt_leg_order
+
+def _vt_order_keys(monkeypatch):
+    monkeypatch.setattr(virtual, "send_order_alert", lambda alert: None)
+    db = {"vt_orders": types.SimpleNamespace(insert_one=lambda doc: types.SimpleNamespace(inserted_id="OID1"))}
+    cursor = memory_state_cursor()
+    orders = virtual.place_vt_order(app_db_cursor=db, redis_cursor=cursor, order_candle=CANDLE, **ORDER)
+    return set(orders[-1])
+
+
+def test_bt_order_has_exactly_the_vt_order_shape(monkeypatch):
+    vt_keys = _vt_order_keys(monkeypatch)
+    bt = place_bt_leg_order(redis_cursor=memory_state_cursor(), order_candle=CANDLE, **ORDER)[-1]
+    assert vt_keys - {"db_order_id"} == set(bt)        # the only vt-only field is the database id
+
+
+def test_bt_order_is_stamped_from_the_candle_and_keeps_its_fields():
+    order = place_bt_leg_order(redis_cursor=memory_state_cursor(), order_candle=CANDLE, **ORDER)[-1]
+    assert order["date"] == "2025-06-02 00:00:00"
+    assert order["order_timestamp"] == "2025-06-02 09:31:07"      # microseconds dropped, like vt
+    assert order["day"] == "Monday" and order["symbol"] == "NIFTY_50"
+    assert order["trigger_price"] == 101.5                        # no explicit trigger -> the candle close
+    assert order["sl_price"] == 70.0 and order["investment"] == 100000    # params folded in, like vt
+    assert order["group_id"] == "r1:2025-06-02:1" and order["leg_key"] == "SPOT" and order["venue"] == "XNSE"
+
+
+def test_bt_order_accumulates_on_the_request_orders_list():
+    c = memory_state_cursor()
+    place_bt_leg_order(redis_cursor=c, order_candle=CANDLE, **ORDER)
+    second = place_bt_leg_order(redis_cursor=c, order_candle=CANDLE, **{**ORDER, "trade_action": "EXIT", "exit_type": "T1"})
+    assert [o["trade_action"] for o in second] == ["ENTRY", "EXIT"]
+    assert [o["trade_action"] for o in fetch_orders_list(c, "r1")] == ["ENTRY", "EXIT"]
+
+
+def test_bt_order_sends_no_alert(monkeypatch):
+    monkeypatch.setattr(utils, "send_order_alert", lambda *a, **k: (_ for _ in ()).throw(AssertionError("alert sent")))
+    monkeypatch.setattr(virtual, "send_order_alert", lambda *a, **k: (_ for _ in ()).throw(AssertionError("alert sent")))
+    place_bt_leg_order(redis_cursor=memory_state_cursor(), order_candle=CANDLE, **ORDER)
+
+
+def test_bt_order_rejects_a_candle_without_a_datetime_timestamp():
+    with pytest.raises(TypeError, match="datetime"):
+        place_bt_leg_order(redis_cursor=memory_state_cursor(), order_candle={**CANDLE, "timestamp": "2025-06-02 09:31"},
+                           **ORDER)
+
+
+def test_bt_order_raises_when_nothing_was_stored():
+    broken = types.SimpleNamespace(rpush=lambda *a: 0, expire=lambda *a: 0, publish=lambda *a: 0,
+                                   lrange=lambda *a: [], llen=lambda k: 0)
+    with pytest.raises(RuntimeError, match="not stored"):
+        place_bt_leg_order(redis_cursor=broken, order_candle=CANDLE, **ORDER)

trigerr-0.7.2/tests/test_ledger_contract.py

@@ -0,0 +1,33 @@
+""" The order ledger must account for every lot, not the last entry per symbol.
+
+`check_open_orders` folds an orders list into open positions keyed by SYMBOL, and each ENTRY order overwrites the
+previous one's fields for that symbol (quantity, quantity_left, trigger_price, group_id ...). Two entries in the
+same instrument — pyramiding, a grid, an adjustment that re-opens a strike, two overlapping structures — therefore
+report only the last lot, and a restart rebuilds only that one. No running strategy does this today; the
+families on the roadmap do.
+"""
+import pytest
+
+from trigerr.orders.orders_utils import check_open_orders
+
+SYMBOL = "NIFTY_50_24000_CE_2026-08-27"
+
+
+def _entry(group, quantity, price, minute):
+    return {"symbol": SYMBOL, "trade_action": "ENTRY", "quantity": quantity, "quantity_left": quantity,
+            "trigger_price": price, "order_timestamp": f"2025-06-02 09:{minute:02d}:00", "position_type": "LONG",
+            "group_id": group, "leg_key": "CE", "data_key": f"UPSTOX:XNSE:{SYMBOL}", "venue": "XNSE", "lot_size": 25}
+
+
+def test_one_entry_is_one_open_position():
+    open_positions = check_open_orders([_entry("r1:2025-06-02:1", 10, 100.0, 16)])
+    assert {s: p["quantity_left"] for s, p in open_positions.items()} == {SYMBOL: 10}
+
+
+@pytest.mark.xfail(strict=True, raises=AssertionError,
+                   reason="S6: open positions are keyed by symbol and the second ENTRY overwrites the first, so a "
+                          "second lot in the same instrument hides the first (15 open lots are reported as 5)")
+def test_two_entries_in_the_same_instrument_are_both_open():
+    orders = [_entry("r1:2025-06-02:1", 10, 100.0, 16), _entry("r1:2025-06-02:2", 5, 110.0, 30)]
+    open_positions = check_open_orders(orders)
+    assert sum(p["quantity_left"] for p in open_positions.values()) == 15

{trigerr-0.7.1 → trigerr-0.7.2}/trigerr/__init__.py

@@ -1,6 +1,6 @@
 from .config import config
 
-__version__ = "0.7.1"
+__version__ = "0.7.2"
 
 
 def set_api_key(key):

{trigerr-0.7.1 → trigerr-0.7.2}/trigerr/framework/__init__.py

@@ -11,6 +11,7 @@ from trigerr.framework.data_feeds import resolve_feeds
 from trigerr.framework.point_in_time import truncate_feeds_to_moment
 from trigerr.framework.clock import iterate_clock_bt, evaluate_should_trade_today
 from trigerr.framework.tick_sources import clock_feed_ticks_live
+from trigerr.framework.bt_state import memory_state_cursor
 from trigerr.framework.execution_core import (
     wait_for_entry_signal, monitor_open_position, enter_legs, place_entry_order_for_leg,
     place_exit_order_for_leg, convert_leg_orders_to_trade, rebuild_legs_from_open_orders,

trigerr-0.7.2/trigerr/framework/bt_state.py

@@ -0,0 +1,44 @@
+""" The state a backtest runs against: an in-process stand-in for the tenant's state Redis.
+
+The execution core keeps a request's orders list, its exit mutex and its pub/sub in
+ctx["state_cursor"]. A live or virtual run hands it the real state Redis; a backtest hands it this
+instead, so a backtest cannot read or write a real Redis key even by mistake — a stray real call
+raises instead of reaching production. It implements only the commands the core and the
+orders_utils helpers actually use, and nothing expires (a run is one process).
+
+A plain dict behind closures, not a class, like the rest of the framework. """
+
+import types
+
+
+def memory_state_cursor():
+    store = {}      # key -> str (strings) or list (lists)
+
+    def rpush(key, *values):
+        store.setdefault(key, []).extend(values)
+        return len(store[key])
+
+    def lrange(key, start, stop):
+        items = store.get(key, [])
+        return list(items[start:] if stop == -1 else items[start:stop + 1])
+
+    def llen(key):
+        return len(store.get(key, []))
+
+    def set_(key, value, nx=False, ex=None):
+        if nx and key in store:
+            return None
+        store[key] = value
+        return True
+
+    def get(key):
+        value = store.get(key)
+        return value if isinstance(value, str) else None
+
+    def delete(key):
+        return 1 if store.pop(key, None) is not None else 0
+
+    return types.SimpleNamespace(
+        rpush=rpush, lrange=lrange, llen=llen, set=set_, get=get, delete=delete,
+        expire=lambda key, seconds: key in store,
+        publish=lambda channel, message: 0)

{trigerr-0.7.1 → trigerr-0.7.2}/trigerr/framework/compiler.py

@@ -302,6 +302,14 @@ def validate(ast):
     elif ast["clock"] not in ast["feeds"]:
         errors.append(f"clock feed '{ast['clock']}' is not declared in feeds")
 
+    from trigerr.framework.data_feeds import DATA_FEED_KINDS    # lazy: data_feeds imports this module
+    for name, spec in ast["feeds"].items():
+        if not isinstance(spec, dict) or "derive" in spec or "kind" not in spec:
+            continue
+        kind = spec["kind"]
+        if kind not in DATA_FEED_KINDS and not (isinstance(kind, str) and kind.startswith("$")):
+            errors.append(f"feed '{name}' has unknown kind '{kind}' (known: {', '.join(sorted(DATA_FEED_KINDS))})")
+
     subscriptions = infer_subscriptions(ast)
     for feed_name in subscriptions:
         if feed_name not in ast["feeds"]:

{trigerr-0.7.1 → trigerr-0.7.2}/trigerr/framework/data_feeds.py

@@ -1,15 +1,13 @@
 """ DATA_FEED_KINDS: one resolver per data source a strategy can declare in
 its FEEDS block. Each resolver is `fetch_historical(feed_spec, ctx) -> rows`
-— a list of dict candles for market-data kinds, or the raw stored value for
-collection/model kinds.
+— a list of dict candles.
 
-Candle-kind resolvers call the SDK's own HTTP-based historical fetchers
-directly — pure, no Redis/Mongo. `mongo_collection`/`pickled_model` read
-whatever the runtime already placed on ctx (`ctx["collections"]`/
-`ctx["models"]`) instead of importing pymongo/pickle here — the same pattern
-`instrument.py` already uses for broker/symbol metadata, and what keeps this
-package infra-free (Decision #8: the SDK is the pure core; live/DB access is
-an engine-side adapter).
+Resolvers call the SDK's own HTTP-based historical fetchers directly — pure,
+no Redis/Mongo, which is what keeps this package infra-free (Decision #8: the
+SDK is the pure core; live/DB access is an engine-side adapter). There is
+deliberately no kind that reads a Mongo collection or loads a model file by
+name: market data comes from the Data API, and a new source is added as a
+named kind (one resolver), never as a pass-through to storage.
 
 `resolve_feeds` is the entry point: it resolves every declared feed — base
 feeds via a DATA_FEED_KINDS resolver, derived feeds via a CANDLE_TRANSFORMS
@@ -76,16 +74,6 @@ def _fetch_options(feed_spec, ctx):
     return _apply_declared_indicators(rows, feed_spec)
 
 
-def _fetch_mongo_collection(feed_spec, ctx):
-    return ctx["collections"][feed_spec["name"]]
-
-
-def _fetch_pickled_model(feed_spec, ctx):
-    """ A model is a single object, not a candle series — a "ref" op can't
-    read it; a native node's plugin reads ctx["feeds"][name] directly. """
-    return ctx["models"][feed_spec["path"]]
-
-
 DATA_FEED_KINDS = {
     "eod": {"fetch_historical": _fetch_eod,
             "spec": {"label": "End-of-day candles", "params": ["symbol", "lookback_days", "exchange"]}},
@@ -97,10 +85,6 @@ DATA_FEED_KINDS = {
     "options": {"fetch_historical": _fetch_options,
                 "spec": {"label": "Option candles",
                          "params": ["symbol", "option_type", "strike_price", "expiry", "granularity"]}},
-    "mongo_collection": {"fetch_historical": _fetch_mongo_collection,
-                          "spec": {"label": "Mongo collection (e.g. nse_pre_open)", "params": ["name"]}},
-    "pickled_model": {"fetch_historical": _fetch_pickled_model,
-                       "spec": {"label": "Pickled ML model", "params": ["path"]}},
 }
 
 

{trigerr-0.7.1 → trigerr-0.7.2}/trigerr/framework/execution_core.py

@@ -28,12 +28,19 @@ is fetched live (vt/lt, via last_candle) but falls back to the clock candle
 in bt, since no strike-aware historical options feed is resolved after entry
 here (that would need historical option data fetched reactively once a
 strike is known - out of scope; this preserves, not introduces, the original
-harness's bt-side simplification for options legs). """
+harness's bt-side simplification for options legs).
+
+bt is a first-class mode here, not a variant of vt: every placement site names vt, lt and bt
+explicitly and raises on anything else, so a backtest can never fall through into a live order.
+A backtest's ctx carries an in-memory state cursor (trigerr.framework.bt_state) and no market-data
+cursor; its orders are stamped from the replayed candle and its trades collect in
+ctx["bt_trades"] for the driver to persist. """
 
 import datetime
 
 from trigerr.orders.virtual import place_vt_order, save_vt_trade
 from trigerr.orders.live import place_lt_order, save_lt_order, poll_order_status, save_lt_trade
+from trigerr.orders.backtest import place_bt_leg_order
 from trigerr.orders.orders_utils import (fetch_orders_list, convert_to_trades, check_existing_order, sequence,
                                          check_open_orders, acquire_exit_mutex, release_exit_mutex, renew_exit_mutex)
 from trigerr.data.market import ltp, last_candle
@@ -89,8 +96,8 @@ def build_leg_order_params(ctx, leg):
     return params
 
 
-def _entry_pricing_window_ok(ctx, price):
-    today = datetime.datetime.today().strftime("%A")
+def _entry_pricing_window_ok(ctx, price, day=None):
+    today = (day or datetime.datetime.today()).strftime("%A")
     return any(slot["start_price"] <= price <= slot["end_price"]
               for slot in ctx["market_config"]["entry_pricing"][today])
 
@@ -130,6 +137,11 @@ def place_entry_order_for_leg(ctx, leg):
     ladder, and registers it in ctx["legs"]. Returns True on success. Does
     NOT poll for lt — enter_legs places every leg first, then reconciles
     (defect #4's ordering fix). """
+    if ctx["mode"] == "bt":
+        return _place_bt_entry_for_leg(ctx, leg)
+    if ctx["mode"] not in ("vt", "lt"):
+        raise ValueError(f"unknown mode {ctx['mode']!r}: refusing to place an entry")
+
     inputs = ctx["parameters"]
     rdb_cursor = ctx["rdb_cursor"]
 
@@ -237,6 +249,60 @@ def place_entry_order_for_leg(ctx, leg):
     return True
 
 
+def _bt_clock_candle(ctx):
+    """ The candle the strategy acted on: the last row of the clock feed's point-in-time view. A
+    backtest fills at its close (PLATFORM_TARGET_ARCHITECTURE §7), and — until historical option
+    pricing exists — prices every leg off it, exactly as _refresh_leg_candles already does. """
+    rows = ctx["feeds"].get(ctx["clock_feed"])
+    if not rows:
+        raise ValueError("backtest has no clock candle to price against")
+    return rows[-1]
+
+
+def _place_bt_entry_for_leg(ctx, leg):
+    """ place_entry_order_for_leg's backtest twin: same sizing, same target/stop ladder, same order
+    shape — but priced off the replayed candle instead of a live tick, and stored only on the
+    in-memory state cursor. Touches no live Redis, database, broker or alert channel. """
+    inputs = ctx["parameters"]
+    candle = _bt_clock_candle(ctx)
+    order_candle = {"symbol": leg["exit_symbol"], "close": candle["close"], "timestamp": candle["timestamp"]}
+
+    if not _entry_pricing_window_ok(ctx, order_candle["close"], day=candle["timestamp"]):
+        ctx["logger"].warning(f"Entry price {order_candle['close']} outside the pricing window "
+                              f"for {candle['timestamp']:%A}")
+        return False
+
+    t1_percent = float(inputs.get("t1_percent", 0))
+    sl_percent = float(inputs.get("c1_sl_percent", inputs.get("sl_percent", 0)))
+
+    entry_price = order_candle["close"]
+    leg["entry_price"] = entry_price
+    leg.update(calculate_target_and_stoploss_prices(entry_price, leg["position_type"], t1_percent, sl_percent))
+    leg["trailing_sl"] = leg["sl_price"]
+    leg["quantity"] = _size_leg(ctx, leg, entry_price)
+    if not leg["quantity"]:
+        return False
+    leg["quantity_left"] = leg["quantity"]
+    leg["order_params"] = build_leg_order_params(ctx, leg)
+
+    orders_list = place_bt_leg_order(
+        redis_cursor=ctx["state_cursor"], order_candle=order_candle,
+        quantity=leg["quantity"], quantity_left=leg["quantity"], position_type=leg["position_type"],
+        transaction_type=leg["transaction_type"], order_type=inputs.get("order_type", "MARKET"),
+        exit_type=None, trade_action="ENTRY", lot_size=leg["lot_size"],
+        user_id=ctx["user_id"], strategy_id=ctx["strategy_id"], request_id=ctx["request_id"],
+        market=ctx["market"], market_type=ctx["market_type"], exchange=leg["order_exchange"],
+        params=leg["order_params"], data_key=leg["data_key"], venue=ctx["venue"],
+        group_id=leg.get("group_id"), leg_key=leg["leg_key"])
+    leg["entry_time"] = _as_datetime(orders_list[-1]["order_timestamp"])
+    leg["tradingsymbol"] = orders_list[-1]["symbol"]
+    ctx["orders_list"] = orders_list
+
+    ctx["legs"][leg["leg_key"]] = leg
+    ctx["entry_spot"] = ctx.get("spot_price", leg["entry_price"])
+    return True
+
+
 def _unwind_filled_legs(ctx, filled_legs):
     """ Immediately market-exits every already-filled leg when a sibling leg
     in the same multi-leg entry failed, instead of leaving a naked position
@@ -278,7 +344,20 @@ def _unwind_filled_legs(ctx, filled_legs):
                     market_type=ctx["market_type"], exchange=leg["order_exchange"], params=leg.get("order_params"),
                     data_key=leg["data_key"], venue=ctx["venue"], group_id=leg.get("group_id"), leg_key=leg["leg_key"])
                 msg = f"Unwound {leg['leg_key']} (vt, MANUAL) after a sibling leg failed to enter.{price_note}"
-            else:
+            elif ctx["mode"] == "bt":
+                candle = _bt_clock_candle(ctx)
+                ctx["orders_list"] = place_bt_leg_order(
+                    redis_cursor=ctx["state_cursor"],
+                    order_candle={"symbol": leg["tradingsymbol"], "timestamp": candle["timestamp"],
+                                 "close": candle["close"]},
+                    quantity=leg["quantity_left"], quantity_left=0, position_type=leg["position_type"],
+                    transaction_type=exit_transaction, order_type="MARKET", exit_type="MANUAL",
+                    trade_action="EXIT", lot_size=leg["lot_size"], user_id=ctx["user_id"],
+                    strategy_id=ctx["strategy_id"], request_id=ctx["request_id"], market=ctx["market"],
+                    market_type=ctx["market_type"], exchange=leg["order_exchange"], params=leg.get("order_params"),
+                    data_key=leg["data_key"], venue=ctx["venue"], group_id=leg.get("group_id"), leg_key=leg["leg_key"])
+                msg = f"Unwound {leg['leg_key']} (bt, MANUAL) after a sibling leg failed to enter."
+            elif ctx["mode"] == "lt":
                 unwind_status, unwind_response = place_lt_order(
                     symbol=leg["tradingsymbol"], exchange=leg["order_exchange"], quantity=leg["quantity_left"],
                     transaction_type=exit_transaction, order_type="MARKET", lot_size=leg["lot_size"],
@@ -317,6 +396,8 @@ def _unwind_filled_legs(ctx, filled_legs):
                             broker=unwind_response.get("broker"), broker_symbol=unwind_response.get("broker_symbol"))
                         ctx["orders_list"] = orders_list
                         msg = f"Unwound {leg['leg_key']} ({leg['tradingsymbol']}) (lt, MANUAL) after a sibling leg failed to enter."
+            else:
+                raise ValueError(f"unknown mode {ctx['mode']!r}: refusing to place an unwind order")
             _alert(ctx, msg, "Leg Unwind")
     finally:
         release_exit_mutex(ctx["state_cursor"], ctx["request_id"], token)
@@ -479,8 +560,12 @@ def convert_leg_orders_to_trade(ctx, record_manual=False):
         trade["combined_pnl"] = net
         if ctx["mode"] == "vt":
             save_vt_trade(app_db_cursor=ctx["app_db_cursor"], redis_cursor=ctx["state_cursor"], trade_dict=trade)
-        else:
+        elif ctx["mode"] == "bt":
+            ctx.setdefault("bt_trades", []).append(trade)   # in memory; the driver persists them once
+        elif ctx["mode"] == "lt":
             save_lt_trade(app_db_cursor=ctx["app_db_cursor"], redis_cursor=ctx["state_cursor"], trade_dict=trade)
+        else:
+            raise ValueError(f"unknown mode {ctx['mode']!r}: refusing to record a trade")
 
 
 def place_exit_order_for_leg(ctx, leg, exit_type, candle):
@@ -511,7 +596,19 @@ def place_exit_order_for_leg(ctx, leg, exit_type, candle):
             market=ctx["market"], market_type=ctx["market_type"], exchange=leg["order_exchange"],
             data_key=leg["data_key"], venue=ctx["venue"], group_id=leg.get("group_id"), leg_key=leg["leg_key"])
 
-    else:
+    elif ctx["mode"] == "bt":
+        leg["quantity_left"] -= exit_quantity
+        ctx["orders_list"] = place_bt_leg_order(
+            redis_cursor=ctx["state_cursor"], order_candle={**candle, "symbol": leg["tradingsymbol"]},
+            position_type=leg["position_type"], quantity=exit_quantity, quantity_left=leg["quantity_left"],
+            transaction_type=exit_transaction, order_type=inputs.get("order_type", "MARKET"),
+            exit_type=exit_type, params=leg["order_params"], lot_size=leg["lot_size"], trade_action="EXIT",
+            trigger_price=_exit_trigger_price(ctx, leg, exit_type, candle),
+            user_id=ctx["user_id"], strategy_id=ctx["strategy_id"], request_id=ctx["request_id"],
+            market=ctx["market"], market_type=ctx["market_type"], exchange=leg["order_exchange"],
+            data_key=leg["data_key"], venue=ctx["venue"], group_id=leg.get("group_id"), leg_key=leg["leg_key"])
+
+    elif ctx["mode"] == "lt":
         order_status, lt_response = place_lt_order(
             symbol=leg["tradingsymbol"], exchange=leg["order_exchange"], quantity=exit_quantity,
             transaction_type=exit_transaction, order_type="MARKET", lot_size=leg["lot_size"],
@@ -549,6 +646,9 @@ def place_exit_order_for_leg(ctx, leg, exit_type, candle):
             broker=lt_response.get("broker"), broker_symbol=lt_response.get("broker_symbol"))
         ctx["orders_list"] = orders_list
 
+    else:
+        raise ValueError(f"unknown mode {ctx['mode']!r}: refusing to place an exit order")
+
     if all(l["quantity_left"] == 0 for l in ctx["legs"].values()):
         convert_leg_orders_to_trade(ctx)
 
@@ -600,7 +700,11 @@ def manual_exit_legs(ctx, prices, leg_keys=None):
                 data_key=leg["data_key"], venue=ctx["venue"], group_id=leg.get("group_id"), leg_key=leg_key)
             exited.append(leg_key)
 
-        else:
+        elif ctx["mode"] == "bt":
+            refused[leg_key] = "manual exit is not available in a backtest"
+            continue
+
+        elif ctx["mode"] == "lt":
             inputs = ctx["parameters"]
             order_status, lt_response = place_lt_order(
                 symbol=leg["tradingsymbol"], exchange=leg["order_exchange"], quantity=exit_quantity,
@@ -642,6 +746,9 @@ def manual_exit_legs(ctx, prices, leg_keys=None):
             ctx["orders_list"] = orders_list
             exited.append(leg_key)
 
+        else:
+            raise ValueError(f"unknown mode {ctx['mode']!r}: refusing to place a manual exit")
+
     if ctx["legs"] and all(l["quantity_left"] == 0 for l in ctx["legs"].values()):
         convert_leg_orders_to_trade(ctx, record_manual=True)
 

{trigerr-0.7.1 → trigerr-0.7.2}/trigerr/framework/point_in_time.py

@@ -10,8 +10,7 @@ live feed only ever holds ticks that have already arrived. """
 def truncate_feeds_to_moment(feeds, moment):
     """ Returns a new {name: rows} with every timestamped feed's rows
     filtered to timestamp <= moment. A feed whose rows aren't timestamped
-    candles (a mongo_collection without a timestamp column, a pickled model
-    object) passes through unchanged — truncation only applies where "point
+    candles passes through unchanged — truncation only applies where "point
     in time" is a meaningful concept. """
     truncated = {}
     for name, rows in feeds.items():