trigerr 0.7.4__tar.gz → 0.7.6__tar.gz

{trigerr-0.7.4/trigerr.egg-info → trigerr-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trigerr
-Version: 0.7.4
+Version: 0.7.6
 Summary: Python tools for quantitative trading research and analysis.
 Author: Anurag Singh Kushwah
 License-Expression: MIT

trigerr-0.7.6/tests/test_capital_used.py

@@ -0,0 +1,94 @@
+"""
+Every trade carries two amounts: `investment`, the capital set aside for it, and `capital_used`, what its entry really
+put to work. `quantity` counts units for spot and futures and lots for everything else (the rule the P&L is priced
+with), and an order carries the `leverage` it was sized with, so the used amount is the position value over it.
+
+Offline: no Mongo, no Redis, no network.
+"""
+import datetime
+
+import pytest
+
+from trigerr.orders import orders_utils
+
+
+def entry_order(**extra):
+    order = {
+        "symbol": "NIFTY_22600_PE", "data_key": "UPSTOX:XNSE:NIFTY_22600_PE", "group_id": "r1:1",
+        "trade_action": "ENTRY", "date": datetime.datetime(2026, 10, 22), "day": "Thursday",
+        "order_timestamp": "2026-10-22 13:38:00", "trigger_price": 136.9, "quantity": 11,
+        "lot_size": 65, "investment": 100000, "position_type": "LONG", "exchange": "NFO",
+        "market": "IN", "order_type": "MARKET", "quantity_left": 0,
+        "user_id": "507f1f77bcf86cd799439011", "strategy_id": "507f1f77bcf86cd799439012",
+        "request_id": "507f1f77bcf86cd799439013",
+    }
+    order.update(extra)
+    return order
+
+
+def exit_order(**extra):
+    order = {
+        "symbol": "NIFTY_22600_PE", "trade_action": "EXIT", "exit_type": "T1", "quantity_left": 0,
+        "order_timestamp": "2026-10-22 13:50:00", "trigger_price": 150.0, "quantity": 11,
+        "position_type": "LONG", "order_type": "MARKET",
+    }
+    order.update(extra)
+    return order
+
+
+def converted(market_type="options", entry=None, exit=None):
+    trades = orders_utils.convert_to_trades(
+        orders_list=[entry_order(**(entry or {})), exit_order(**(exit or {}))],
+        market_type=market_type, order_exit_levels=["T1"], mode="vt", broker="zerodha")
+    assert trades is not None and len(trades) == 1
+    return trades[0]
+
+
+def test_options_count_lots_times_lot_size():
+    trade = converted()
+    assert trade["capital_used"] == round(136.9 * 11 * 65, 2) == 97883.5
+
+
+def test_the_capital_set_aside_is_kept_and_is_a_little_more_than_was_used():
+    trade = converted()
+    assert trade["investment"] == 100000
+    assert trade["capital_used"] < trade["investment"]
+
+
+def test_futures_and_spot_count_units_not_lots():
+    futures = converted(market_type="futures", entry={"quantity": 3, "lot_size": 50, "trigger_price": 100}, exit={"quantity": 3})
+    assert futures["capital_used"] == 300
+    spot = converted(market_type="spot", entry={"quantity": 10, "lot_size": 1, "trigger_price": 250}, exit={"quantity": 10})
+    assert spot["capital_used"] == 2500
+
+
+def test_leverage_divides_the_position_value():
+    trade = converted(entry={"quantity": 10, "lot_size": 25, "trigger_price": 100, "leverage": 5}, exit={"quantity": 10})
+    assert trade["capital_used"] == 5000
+    futures = converted(market_type="futures", entry={"quantity": 3, "trigger_price": 100, "leverage": 10}, exit={"quantity": 3})
+    assert futures["capital_used"] == 30
+
+
+@pytest.mark.parametrize("leverage", [None, 0, 1])
+def test_no_leverage_counts_as_one(leverage):
+    extra = {} if leverage is None else {"leverage": leverage}
+    assert converted(entry=extra)["capital_used"] == 97883.5
+
+
+def test_a_fractional_crypto_position_keeps_its_cents():
+    order = entry_order(market="CRYPTO", quantity=0.5, trigger_price=60000.25, lot_size=1, leverage=10)
+    assert orders_utils.capital_used(order, "futures") == 3000.01
+
+
+def test_every_trade_of_a_run_carries_it():
+    orders = [entry_order(group_id="r1:1"), exit_order(), entry_order(group_id="r1:2", trigger_price=140.0), exit_order(trigger_price=120.0)]
+    trades = orders_utils.convert_to_trades(orders_list=orders, market_type="options", order_exit_levels=["T1"], mode="vt", broker="zerodha")
+    assert [trade["capital_used"] for trade in trades] == [97883.5, round(140.0 * 11 * 65, 2)]
+
+
+def test_leverage_changes_what_was_used_not_the_profit_or_the_charges():
+    plain = converted()
+    leveraged = converted(entry={"leverage": 5})
+    assert leveraged["capital_used"] == plain["capital_used"] / 5
+    for field in ("pnl", "net_pnl", "brokerage", "pnl_percent"):
+        assert leveraged[field] == plain[field]

{trigerr-0.7.4 → trigerr-0.7.6}/tests/test_exit_mutex.py

@@ -159,8 +159,9 @@ def test_an_exit_poll_longer_than_the_ttl_keeps_the_mutex_held(monkeypatch):
     open_polls = {"n": 300}
     seen_free = []
 
-    def fake_post(url, json, headers):
+    def fake_post(url, json, headers, timeout):
         response = type("R", (), {})()
+        response.status_code = 200
         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}

{trigerr-0.7.4 → trigerr-0.7.6}/tests/test_live_orders_correlation.py

@@ -6,6 +6,7 @@ from trigerr.orders import live
 
 def _mock_response(payload):
     response = MagicMock()
+    response.status_code = 200
     response.json.return_value = payload
     return response
 

trigerr-0.7.6/tests/test_live_orders_time_limits.py

@@ -0,0 +1,196 @@
+""" Calls to the OMS carry a time limit, a placement with no answer is resent under its own key until the OMS has
+a result for it, and a fill wait that gets no answer keeps waiting: none of these says anything about the order. """
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from trigerr import utils
+from trigerr.orders import live
+
+IN_PROGRESS = {"status": "ERROR", "message": "Duplicate request: an order with this idempotency_key is still in progress."}
+DONE = {"status": "COMPLETED", "timestamp": "2026-11-11 10:00:00", "filled_quantity": 75, "order_quantity": 75}
+
+
+def reply(payload, status_code=200):
+    response = MagicMock()
+    response.status_code = status_code
+    response.json.return_value = payload
+    return response
+
+
+def setup_function(function):
+    live.orders_url = "http://testserver/"
+
+
+@pytest.fixture
+def post():
+    with patch("trigerr.orders.live.requests.post") as mock_post, patch("trigerr.orders.live.time.sleep"):
+        yield mock_post
+
+
+def test_every_order_call_has_a_time_limit(post):
+    post.return_value = reply(dict(DONE, status="SUCCESS"))
+    live.place_live_order("cred-1", {"symbol": "INFY"})
+    live.modify_live_order("cred-1", {"order_id": "o1"})
+    live.check_order_status("cred-1", "o1", "NFO")
+    live.validate_credential("cred-1")
+    post.return_value = reply(DONE)
+    live.poll_order_status("cred-1", "o1", "NFO")
+    limits = [call.kwargs.get("timeout") for call in post.call_args_list]
+    assert limits == [live.PLACE_TIMEOUT, live.CALL_TIMEOUT, live.CALL_TIMEOUT, live.CALL_TIMEOUT, live.CALL_TIMEOUT]
+    assert all(limit and all(limit) for limit in limits)
+
+
+def test_the_funds_read_has_a_time_limit():
+    with patch("trigerr.utils.requests.post") as mock_post:
+        mock_post.return_value = reply({"status": "SUCCESS", "message": "Fund Found", "data": {"net_balance": 5.0}})
+        assert utils.fetch_available_funds("cred-1") == 5.0
+    assert mock_post.call_args.kwargs["timeout"]
+
+
+@pytest.mark.parametrize("no_answer", [live.requests.Timeout("slow"), reply("<html>bad gateway</html>", 502), reply({}, 504)])
+def test_a_placement_with_no_answer_is_resent_under_the_same_key(post, no_answer):
+    post.side_effect = [no_answer, reply({"status": "SUCCESS", "order_id": "OID1"})]
+    assert live.place_live_order("cred-1", {"symbol": "INFY"})["order_id"] == "OID1"
+    keys = [call.kwargs["json"]["idempotency_key"] for call in post.call_args_list]
+    assert len(keys) == 2 and keys[0] == keys[1]
+
+
+def test_a_resent_placement_waits_for_the_first_send_to_finish(post):
+    post.side_effect = [live.requests.Timeout("slow"), reply(IN_PROGRESS), reply(IN_PROGRESS),
+                        reply({"status": "SUCCESS", "order_id": "OID1"})]
+    assert live.place_live_order("cred-1", {"symbol": "INFY"})["order_id"] == "OID1"
+    keys = {call.kwargs["json"]["idempotency_key"] for call in post.call_args_list}
+    assert post.call_count == 4 and len(keys) == 1
+
+
+def test_the_wait_for_the_first_send_is_bounded(post):
+    post.side_effect = [live.requests.Timeout("slow")] + [reply(IN_PROGRESS)] * 50
+    clock = iter(range(0, 10000, 10))
+    with patch("trigerr.orders.live.time.monotonic", side_effect=lambda: next(clock)):
+        answer = live.place_live_order("cred-1", {"symbol": "INFY"})
+    assert answer == IN_PROGRESS
+    assert post.call_count < 50
+
+
+def test_a_plain_refusal_is_not_resent(post):
+    post.return_value = reply({"status": "ERROR", "message": "Insufficient funds"})
+    assert live.place_live_order("cred-1", {"symbol": "INFY"})["message"] == "Insufficient funds"
+    assert post.call_count == 1
+
+
+@pytest.mark.parametrize("no_answer", [live.requests.ConnectionError("reset"), live.requests.Timeout("slow"),
+                                       reply("<html>bad gateway</html>", 502)])
+def test_a_fill_wait_with_no_answer_keeps_waiting(post, no_answer):
+    post.side_effect = [reply({"status": "OPEN"}), no_answer, no_answer, reply(DONE)]
+    waits = []
+    status, order = live.poll_order_status("cred-1", "OID1", "NFO", on_wait=lambda: waits.append(1))
+    assert status == "success" and order["filled_quantity"] == 75
+    assert len(waits) == 3
+
+
+def test_a_fill_wait_with_no_answer_still_ends_at_its_time_limit(post):
+    post.side_effect = live.requests.ConnectionError("down")
+    clock = iter(range(0, 100000, 100))
+    with patch("trigerr.orders.live.time.time", side_effect=lambda: next(clock)):
+        status, order = live.poll_order_status("cred-1", "OID1", "NFO", max_wait_seconds=1000)
+    assert status == "timeout" and order is None
+
+
+OPEN = {"status": "OPEN", "timestamp": "2026-11-11 10:00:00", "filled_quantity": 0, "order_quantity": 75}
+
+
+def ended(status, filled):
+    return dict(DONE, status=status, filled_quantity=filled)
+
+
+def paths(post):
+    return [call.kwargs["url"].rsplit("/", 1)[1] for call in post.call_args_list]
+
+
+def ticking(step):
+    """ A clock that moves `step` seconds on every read. """
+    clock = iter(range(0, 1000000, step))
+    return patch("trigerr.orders.live.time.time", side_effect=lambda: next(clock))
+
+
+def test_an_order_that_fills_settles_with_no_cancel(post):
+    post.side_effect = [reply(OPEN), reply(DONE)]
+    settled, order = live.settle_live_order("cred-1", "OID1", "NFO")
+    assert settled and live.filled_lots(order, 75) == 1
+    assert "cancel_order" not in paths(post)
+
+
+@pytest.mark.parametrize("status,filled,lots", [("PARTIAL", 150, 2), ("REJECTED", 0, 0), ("CANCELLED", 0, 0)])
+def test_an_order_that_ends_short_settles_with_what_filled(post, status, filled, lots):
+    post.return_value = reply(ended(status, filled))
+    settled, order = live.settle_live_order("cred-1", "OID1", "NFO")
+    assert settled and live.filled_lots(order, 75) == lots
+    assert "cancel_order" not in paths(post)
+
+
+def open_until_cancelled(post, then):
+    """ The OMS says OPEN until a cancel is asked for, and `then` after it. """
+    def answer(url, **kwargs):
+        if url.endswith("cancel_order"):
+            return reply({"status": "SUCCESS"})
+        return reply(then if "cancel_order" in paths(post)[:-1] else OPEN)
+    post.side_effect = answer
+
+
+def test_an_order_still_open_after_the_wait_is_cancelled_then_settled(post):
+    open_until_cancelled(post, then=ended("PARTIAL", 75))
+    with ticking(10):
+        settled, order = live.settle_live_order("cred-1", "OID1", "NFO", wait_s=60)
+    assert paths(post).count("cancel_order") == 1 and paths(post)[-1] == "check_order_status"
+    assert settled and live.filled_lots(order, 75) == 1
+
+
+def test_an_order_still_open_after_the_cancel_is_not_settled(post):
+    open_until_cancelled(post, then=OPEN)
+    with ticking(10):
+        settled, order = live.settle_live_order("cred-1", "OID1", "NFO", wait_s=60)
+    assert not settled and order["status"] == "OPEN"
+    assert paths(post).count("cancel_order") == 1
+
+
+@pytest.mark.parametrize("unclear", [{"status": "ERROR", "message": "Order Details could not be found"}, {"status": "WHAT"}])
+def test_only_unclear_answers_is_not_settled(post, unclear):
+    post.return_value = reply(dict(unclear, timestamp="2026-11-11 10:00:00"))
+    with ticking(10):
+        settled, _ = live.settle_live_order("cred-1", "OID1", "NFO", wait_s=60)
+    assert not settled
+    assert paths(post).count("cancel_order") == 1 and paths(post).count("check_order_status") > 2
+
+
+def test_an_unclear_answer_does_not_end_the_wait(post):
+    unclear = {"status": "ERROR", "message": "Exception in Check Order Status", "timestamp": "2026-11-11 10:00:00"}
+    post.side_effect = [reply(unclear), reply(OPEN), reply(DONE)]
+    settled, order = live.settle_live_order("cred-1", "OID1", "NFO")
+    assert settled and order["status"] == "COMPLETED"
+    assert paths(post) == ["check_order_status"] * 3
+
+
+def test_no_answer_at_all_is_not_settled(post):
+    post.side_effect = live.requests.ConnectionError("down")
+    with ticking(40):
+        settled, order = live.settle_live_order("cred-1", "OID1", "NFO", wait_s=60)
+    assert not settled and order is None
+
+
+@pytest.mark.parametrize("order_response,expected", [
+    ({"status": "SUCCESS", "order_id": "o1", "sub_orders": [{"status": "OPEN"}]}, "o1"),
+    ({"status": "ERROR", "order_id": "o1", "sub_orders": [{"status": "OPEN"}, {"status": "REJECTED"}]}, "o1"),
+    ({"status": "ERROR", "order_id": "o1", "sub_orders": [{"status": "REJECTED"}]}, None),
+    ({"status": "ERROR", "message": "placement UNCONFIRMED"}, None),
+    (None, None),
+])
+def test_placed_order_id_is_there_only_when_a_piece_is_at_the_broker(order_response, expected):
+    assert live.placed_order_id(order_response) == expected
+
+
+def test_filled_lots():
+    assert live.filled_lots({"filled_quantity": 150}, 75) == 2
+    assert live.filled_lots({"filled_quantity": None}, 75) == 0
+    assert live.filled_lots(None, 75) == 0
+    assert live.filled_lots({"filled_quantity": 1.5}) == 1.5

trigerr-0.7.6/tests/test_live_record_saves.py

@@ -0,0 +1,105 @@
+""" Saving a live order or trade: a few tries, and an answer that says where the record really is. """
+import datetime
+from unittest.mock import patch
+
+import pytest
+from pymongo.errors import AutoReconnect, DuplicateKeyError
+
+from trigerr.orders import live, orders_utils
+from test_orders_schema import FakeDB, FakeRedis
+
+
+class FlakyCollection:
+    """ insert_one fails `failures` times, then saves. `lands` True: a failed try did reach the database. """
+    def __init__(self, failures, lands=False):
+        self.failures, self.lands, self.docs = failures, lands, []
+
+    def insert_one(self, doc):
+        doc.setdefault("_id", "id0")
+        if any(saved["_id"] == doc["_id"] for saved in self.docs):
+            raise DuplicateKeyError("duplicate")
+        if self.failures:
+            self.failures -= 1
+            if self.lands:
+                self.docs.append(dict(doc))
+            raise AutoReconnect("connection lost")
+        self.docs.append(dict(doc))
+        return type("Result", (), {"inserted_id": doc["_id"]})()
+
+
+class FlakyRedis(FakeRedis):
+    """ rpush fails `failures` times, then works. `lands` True: a failed try did reach Redis. """
+    def __init__(self, failures, lands=False):
+        super().__init__()
+        self.failures, self.lands = failures, lands
+
+    def rpush(self, key, value):
+        if self.failures:
+            self.failures -= 1
+            if self.lands:
+                super().rpush(key, value)
+            raise ConnectionError("socket closed")
+        return super().rpush(key, value)
+
+
+@pytest.fixture(autouse=True)
+def quiet():
+    with patch("trigerr.orders.orders_utils.time.sleep"), patch("trigerr.orders.live.send_order_alert"):
+        yield
+
+
+def save_order(db, redis_cursor):
+    return live.save_lt_order(app_db_cursor=db, redis_cursor=redis_cursor, orders_list=[], symbol="NIFTY_23450_CE", quantity=2,
+                              user_id="u1", strategy_id="s1", request_id="r1", exchange="NFO", order_id="OID1",
+                              exchange_timestamp=datetime.datetime(2026, 1, 1, 9, 20))
+
+
+def db_with(collection):
+    db = FakeDB()
+    db.cols["lt_orders"] = db.cols["lt_trades"] = collection
+    return db
+
+
+def test_a_save_that_fails_twice_then_works_is_a_success():
+    collection, redis_cursor = FlakyCollection(failures=2), FlakyRedis(failures=2)
+    status, orders = save_order(db_with(collection), redis_cursor)
+    assert status == "success" and len(collection.docs) == 1 and len(orders) == 1
+
+
+@pytest.mark.parametrize("failures", [1, 2])
+def test_a_try_that_did_land_is_not_saved_twice(failures):
+    collection, redis_cursor = FlakyCollection(failures, lands=True), FlakyRedis(failures, lands=True)
+    status, orders = save_order(db_with(collection), redis_cursor)
+    assert status == "success" and len(collection.docs) == 1 and len(orders) == 1
+
+
+def test_mongo_down_and_redis_up_is_db_failed_and_the_order_is_in_the_list():
+    status, orders = save_order(db_with(FlakyCollection(failures=99)), FakeRedis())
+    assert status == "db_failed"
+    assert len(orders) == 1 and orders[0]["order_id"] == "OID1" and "db_order_id" not in orders[0]
+
+
+def test_redis_down_is_failed_whatever_mongo_did():
+    collection = FlakyCollection(failures=0)
+    status, orders = save_order(db_with(collection), FlakyRedis(failures=99))
+    assert status == "failed" and orders == [] and len(collection.docs) == 1
+
+
+def test_a_failed_order_alert_does_not_fail_the_save():
+    with patch("trigerr.orders.live.send_order_alert", side_effect=RuntimeError("alert service down")):
+        status, orders = save_order(FakeDB(), FakeRedis())
+    assert status == "success" and len(orders) == 1
+
+
+def test_save_lt_trade_says_whether_mongo_took_it():
+    trade = {"request_id": "r1", "user_id": "u1", "pnl": 10}
+    assert live.save_lt_trade(FakeDB(), FakeRedis(), dict(trade)) is True
+    redis_cursor = FakeRedis()
+    assert live.save_lt_trade(db_with(FlakyCollection(failures=99)), redis_cursor, dict(trade)) is False
+    assert len(redis_cursor.lists["r1_trades"]) == 1
+
+
+def test_add_order_to_redis_answers():
+    order = {"user_id": "u1", "symbol": "X"}
+    assert orders_utils.add_order_to_redis(FakeRedis(), "r1", order, "vt") is True
+    assert orders_utils.add_order_to_redis(FlakyRedis(failures=99), "r1", order, "vt") is False