trigerr 0.7.0__tar.gz → 0.7.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trigerr
-Version: 0.7.0
+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_exit_mutex.py

@@ -0,0 +1,183 @@
+""" Task B3 (spec §8.3 manual exits): the per-request exit mutex that
+serializes everyone who places exit orders for a request — a manual exit
+(OMS) and a running strategy's own exits — so a leg is never exited twice.
+
+Offline: a tiny in-memory fake Redis (SET NX EX / GET / DELETE), no network.
+"""
+import time
+
+from trigerr.orders import live
+from trigerr.orders.orders_utils import (acquire_exit_mutex, release_exit_mutex, renew_exit_mutex,
+                                         EXIT_MUTEX_TTL_S)
+
+
+class FakeRedis:
+    """ SET NX EX / GET / DELETE / EXPIRE with real expiry against a settable
+    clock (self.now), so a test can let time pass past the mutex TTL. """
+    def __init__(self):
+        self._kv = {}
+        self._expires = {}
+        self.now = 0.0
+
+    def _alive(self, key):
+        if key in self._expires and self.now >= self._expires[key]:
+            self._kv.pop(key, None)
+            self._expires.pop(key, None)
+        return key in self._kv
+
+    def set(self, key, value, nx=False, ex=None):
+        if nx and self._alive(key):
+            return None
+        self._kv[key] = value
+        if ex is not None:
+            self._expires[key] = self.now + ex
+        return True
+
+    def get(self, key):
+        return self._kv.get(key) if self._alive(key) else None
+
+    def delete(self, key):
+        self._expires.pop(key, None)
+        return self._kv.pop(key, None) is not None
+
+    def expire(self, key, seconds):
+        if not self._alive(key):
+            return False
+        self._expires[key] = self.now + seconds
+        return True
+
+
+def test_acquire_returns_a_token_when_free():
+    redis_cursor = FakeRedis()
+    token = acquire_exit_mutex(redis_cursor, "r1")
+    assert token is not None
+    assert redis_cursor.get("r1:exit_mutex") == token
+
+
+def test_acquire_waits_then_succeeds_once_the_holder_releases(monkeypatch):
+    redis_cursor = FakeRedis()
+    sleeps = []
+    monkeypatch.setattr(time, "sleep", lambda s: sleeps.append(s))
+
+    first_token = acquire_exit_mutex(redis_cursor, "r1")
+
+    # The real SET NX fails while the first holder has it; make the first
+    # retry fail, then release before the second retry succeeds.
+    attempts = {"n": 0}
+    real_set = redis_cursor.set
+
+    def flaky_set(key, value, nx=False, ex=None):
+        attempts["n"] += 1
+        if attempts["n"] == 1:
+            return None  # still held on the first retry
+        redis_cursor.delete("r1:exit_mutex")  # the first holder released it
+        return real_set(key, value, nx=nx, ex=ex)
+
+    monkeypatch.setattr(redis_cursor, "set", flaky_set)
+    second_token = acquire_exit_mutex(redis_cursor, "r1", wait_s=5)
+    assert second_token is not None
+    assert second_token != first_token
+    assert sleeps, "acquire_exit_mutex must sleep between retries"
+
+
+def test_acquire_times_out_when_never_released(monkeypatch):
+    redis_cursor = FakeRedis()
+    acquire_exit_mutex(redis_cursor, "r1")  # holds it forever
+
+    monkeypatch.setattr(time, "sleep", lambda s: None)
+    clock = {"t": 0.0}
+    monkeypatch.setattr(time, "monotonic", lambda: clock["t"])
+
+    # First monotonic() call sets the deadline; make time "pass" fully on the
+    # very first is-it-past-the-deadline check so the loop returns None
+    # immediately instead of actually looping wait_s/0.2 times.
+    real_monotonic = time.monotonic
+    calls = {"n": 0}
+
+    def fake_monotonic():
+        calls["n"] += 1
+        if calls["n"] == 1:
+            return 0.0  # deadline = 0.0 + wait_s
+        return 10 ** 6  # every later check is long past it
+    monkeypatch.setattr(time, "monotonic", fake_monotonic)
+
+    token = acquire_exit_mutex(redis_cursor, "r1", wait_s=1)
+    assert token is None
+
+
+def test_release_deletes_only_when_token_still_matches():
+    redis_cursor = FakeRedis()
+    token = acquire_exit_mutex(redis_cursor, "r1")
+    release_exit_mutex(redis_cursor, "r1", "not-the-token")
+    assert redis_cursor.get("r1:exit_mutex") == token  # untouched
+
+    release_exit_mutex(redis_cursor, "r1", token)
+    assert redis_cursor.get("r1:exit_mutex") is None
+
+
+def test_release_is_a_noop_when_key_already_expired_or_gone():
+    redis_cursor = FakeRedis()
+    release_exit_mutex(redis_cursor, "r1", "whatever")  # must not raise
+    assert redis_cursor.get("r1:exit_mutex") is None
+
+
+# ---------------------------------------------------------------------------
+# S5: renewal while an exit order waits for its fill
+# ---------------------------------------------------------------------------
+
+def test_renew_extends_the_ttl_for_its_own_token():
+    redis_cursor = FakeRedis()
+    token = acquire_exit_mutex(redis_cursor, "r1")
+    redis_cursor.now = EXIT_MUTEX_TTL_S - 1
+    renew_exit_mutex(redis_cursor, "r1", token)
+    redis_cursor.now = EXIT_MUTEX_TTL_S + 60  # past the original expiry
+    assert redis_cursor.get("r1:exit_mutex") == token
+
+
+def test_renew_never_touches_someone_elses_mutex():
+    redis_cursor = FakeRedis()
+    other = acquire_exit_mutex(redis_cursor, "r1")
+    redis_cursor.now = EXIT_MUTEX_TTL_S - 1
+    renew_exit_mutex(redis_cursor, "r1", "stale-token")
+    redis_cursor.now = EXIT_MUTEX_TTL_S
+    assert redis_cursor.get("r1:exit_mutex") is None, f"{other} must expire on its own schedule"
+
+
+def test_renew_does_not_resurrect_an_expired_mutex():
+    redis_cursor = FakeRedis()
+    token = acquire_exit_mutex(redis_cursor, "r1")
+    redis_cursor.now = EXIT_MUTEX_TTL_S + 1
+    renew_exit_mutex(redis_cursor, "r1", token)
+    assert redis_cursor.get("r1:exit_mutex") is None
+
+
+def test_an_exit_poll_longer_than_the_ttl_keeps_the_mutex_held(monkeypatch):
+    """ A MARKET exit that sits OPEN for 5 minutes (> the 120 s TTL): with
+    on_wait renewing, nobody else can take the mutex until the fill. """
+    redis_cursor = FakeRedis()
+    token = acquire_exit_mutex(redis_cursor, "r1")
+    open_polls = {"n": 300}
+    seen_free = []
+
+    def fake_post(url, json, headers):
+        response = type("R", (), {})()
+        status = "OPEN" if open_polls["n"] > 0 else "COMPLETED"
+        open_polls["n"] -= 1
+        response.json = lambda: {"status": status, "timestamp": "2026-09-28 10:00:00", "average_price": 100.0}
+        return response
+
+    def fake_sleep(seconds):
+        redis_cursor.now += seconds
+        seen_free.append(acquire_exit_mutex(redis_cursor, "r1", wait_s=0) is not None)
+
+    monkeypatch.setattr(live.requests, "post", fake_post)
+    monkeypatch.setattr(live.time, "sleep", fake_sleep)
+    monkeypatch.setattr(live.time, "time", lambda: redis_cursor.now)
+    live.orders_url = "http://testserver/"
+
+    status, _ = live.poll_order_status("c1", "OID1", "NFO",
+                                       on_wait=lambda: renew_exit_mutex(redis_cursor, "r1", token))
+    assert status == "success"
+    assert redis_cursor.now >= 300
+    assert not any(seen_free), "the mutex must never be free while the exit is still OPEN"
+    assert redis_cursor.get("r1:exit_mutex") == token

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.0 → trigerr-0.7.2}/tests/test_live_orders_correlation.py

@@ -127,3 +127,59 @@ def test_validate_credential_never_sends_credential_values():
 
     sent_body = mock_post.call_args.kwargs["json"]
     assert set(sent_body.keys()) == {"credential_id"}
+
+
+# ---------------------------------------------------------------------------
+# S6: idempotency key -- one per call, reused only for transport retries
+# ---------------------------------------------------------------------------
+
+def test_place_live_order_sends_idempotency_key_at_top_level():
+    with patch("trigerr.orders.live.requests.post") as mock_post:
+        mock_post.return_value = _mock_response({"status": "SUCCESS"})
+        live.place_live_order(credential_id="cred-1", order_details={"symbol": "INFY"})
+
+    sent_body = mock_post.call_args.kwargs["json"]
+    assert sent_body["idempotency_key"]
+    assert "idempotency_key" not in sent_body["order_params"]
+
+
+def test_transport_retry_resends_the_same_key():
+    """ The OMS may have placed the order before the connection dropped: the
+    retry must carry the same key so the OMS replays instead of re-placing. """
+    with patch("trigerr.orders.live.requests.post") as mock_post, patch("trigerr.orders.live.time.sleep"):
+        mock_post.side_effect = [live.requests.ConnectionError("reset"),
+                                 _mock_response({"status": "SUCCESS", "order_id": "OID1"})]
+        response = live.place_live_order(credential_id="cred-1", order_details={"symbol": "INFY"})
+
+    assert response["order_id"] == "OID1"
+    keys = [c.kwargs["json"]["idempotency_key"] for c in mock_post.call_args_list]
+    assert len(keys) == 2 and keys[0] == keys[1]
+
+
+def test_each_call_gets_a_fresh_key():
+    """ The OMS keeps an ERROR result under its key for 24 h: a later retry of
+    a rejected order must not reuse the key, or it can never be placed. """
+    with patch("trigerr.orders.live.requests.post") as mock_post:
+        mock_post.return_value = _mock_response({"status": "ERROR"})
+        live.place_live_order(credential_id="cred-1", order_details={"symbol": "INFY"})
+        live.place_live_order(credential_id="cred-1", order_details={"symbol": "INFY"})
+
+    keys = [c.kwargs["json"]["idempotency_key"] for c in mock_post.call_args_list]
+    assert keys[0] != keys[1]
+
+
+def test_transport_retries_are_bounded_then_return_none():
+    with patch("trigerr.orders.live.requests.post") as mock_post, patch("trigerr.orders.live.time.sleep"):
+        mock_post.side_effect = live.requests.ConnectionError("down")
+        assert live.place_live_order(credential_id="cred-1", order_details={"symbol": "INFY"}) is None
+    assert mock_post.call_count == 3
+
+
+def test_poll_order_status_calls_on_wait_once_per_open_poll():
+    responses = [_mock_response({"status": "OPEN"}), _mock_response({"status": "OPEN"}),
+                 _mock_response({"status": "COMPLETED", "timestamp": "2026-09-28 10:00:00"})]
+    waits = []
+    with patch("trigerr.orders.live.requests.post", side_effect=responses), patch("trigerr.orders.live.time.sleep"):
+        status, _ = live.poll_order_status("cred-1", "OID1", "NFO", on_wait=lambda: waits.append(1))
+    assert status == "success"
+    assert len(waits) == 2

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

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

{trigerr-0.7.0 → 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.0 → 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.0 → 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"]}},
 }