fixtureqa 0.4.1__tar.gz → 0.4.3__tar.gz

{fixtureqa-0.4.1/fixtureqa.egg-info → fixtureqa-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.4.1
+Version: 0.4.3
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE

{fixtureqa-0.4.1 → fixtureqa-0.4.3}/fixture/core/fix_time.py

@@ -7,12 +7,16 @@ lands here once.
 """
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 
 
-def utc_timestamp(*, ms: bool = False) -> str:
-    """FIX UTCTimestamp (60/52-style): YYYYMMDD-HH:MM:SS[.mmm]."""
+def utc_timestamp(*, ms: bool = False, offset_s: float = 0.0) -> str:
+    """FIX UTCTimestamp (60/52-style): YYYYMMDD-HH:MM:SS[.mmm].
+
+    offset_s shifts the instant into the future (expiry tags 126/432)."""
     now = datetime.now(timezone.utc)
+    if offset_s:
+        now += timedelta(seconds=offset_s)
     if ms:
         return now.strftime("%Y%m%d-%H:%M:%S.%f")[:-3]
     return now.strftime("%Y%m%d-%H:%M:%S")

{fixtureqa-0.4.1 → fixtureqa-0.4.3}/fixture/core/perf_models.py

@@ -106,6 +106,14 @@ class PayloadConfig(BaseModel):
     # exec_template_id shapes the venue's ack/fill ExecReports. Omitted → built-in builders.
     order_template_id: Optional[str] = None
     exec_template_id: Optional[str] = None
+    # Send-options parity with the standard send UI (client-injected messages only):
+    # auto_expiry rewrites ExpireTime(126)/ExpireDate(432) to a future instant when
+    # the message already carries them (never inserts); gen_rules set tag → generator
+    # expression / literal (insert-or-replace) on every order/scenario message.
+    auto_expiry: bool = True
+    expiry_offset: int = Field(default=1, ge=0)
+    expiry_unit: Literal["minutes", "hours", "days"] = "days"
+    gen_rules: dict[str, str] = Field(default_factory=dict)
 
     @model_validator(mode="after")
     def _weights(self) -> "PayloadConfig":

{fixtureqa-0.4.1 → fixtureqa-0.4.3}/fixture/core/perf_payload.py

@@ -17,11 +17,30 @@ Tokens (in template field values):
   {ref:<tpl>.clordid}  the ClOrdID generated earlier in this scenario instance
                        for template <tpl> (sequential scenarios only, earlier msg)
   {<var>}          any key from payload.variables
+
+Value generators (same set the standard-send UI evaluates client-side; here
+they are evaluated server-side, fresh per message): uuid() · random_str() /
+random_str(n) · random_int(a,b) · seq() / seq(width) / seq(width,start) ·
+timestamp() · date(). A field value that is exactly one bare call is replaced;
+generators also embed in static text as {gen(...)} — e.g. "ORD-{seq(8)}" →
+"ORD-00000001". seq keeps one counter per tag per run. A bare unknown
+name(...) is sent as-is; an unknown {name(...)} is rejected at run start.
+
+Send-options parity (client-injected messages only):
+  payload.gen_rules    tag → expression, insert-or-replace on every order /
+                       scenario message (correlation tag is engine-protected)
+  payload.auto_expiry  rewrite ExpireTime(126)/ExpireDate(432) to now +
+                       expiry_offset expiry_unit — only when already present
+
+ClOrdID(11) is guaranteed unique per order: a template/rule tag-11 value with
+no token/generator would repeat verbatim on every order of the run, so it is
+replaced with a fresh engine ClOrdID.
 """
 from __future__ import annotations
 
 import random
 import re
+import string
 import uuid
 from typing import Optional
 
@@ -70,6 +89,59 @@ def _tokens(value: str) -> list[str]:
     return _TOKEN_RE.findall(value) if isinstance(value, str) else []
 
 
+# -- value generators (mirror frontend SendOptions.evalGenerator) ----------
+
+_GEN_RE = re.compile(r"^(\w+)\(([^)]*)\)$")
+_ALNUM = string.ascii_letters + string.digits
+_GENERATOR_NAMES = {"uuid", "random_str", "random_int", "seq", "timestamp", "date"}
+_EXPIRY_UNIT_S = {"minutes": 60, "hours": 3600, "days": 86400}
+
+
+def _gen_call(name: str, raw_args: str, tag: int, counters: dict[int, int]) -> Optional[str]:
+    """Evaluate one generator call; None = unknown name / invalid args."""
+    args = [a.strip() for a in raw_args.split(",")] if raw_args.strip() else []
+    if name == "uuid":
+        return _uuid()
+    if name == "random_str":
+        n = _to_int(args[0], 8) if args else 8
+        return "".join(random.choices(_ALNUM, k=min(n, 256) if n > 0 else 8))
+    if name == "random_int":
+        try:
+            a, b = int(float(args[0])), int(float(args[1]))
+        except (IndexError, TypeError, ValueError):
+            return None
+        return str(random.randint(min(a, b), max(a, b)))
+    if name == "seq":
+        # seq() / seq(width) / seq(width, start) — incrementing counter,
+        # zero-padded to width; one counter per tag per run.
+        width = _to_int(args[0], 0) if args else 0
+        start = _to_int(args[1], 1) if len(args) > 1 else 1
+        n = counters.get(tag, start)
+        counters[tag] = n + 1
+        return str(n).zfill(width) if width > 0 else str(n)
+    if name == "timestamp":
+        return utc_timestamp()
+    if name == "date":
+        return utc_timestamp()[:8]
+    return None
+
+
+def _eval_generator(value: str, tag: int, counters: dict[int, int]) -> str:
+    """Evaluate a whole-value generator expression; pass literals through."""
+    m = _GEN_RE.match(value.strip())
+    if not m:
+        return value
+    out = _gen_call(m.group(1), m.group(2), tag, counters)
+    return value if out is None else out
+
+
+def _is_dynamic(value: str) -> bool:
+    """True when a template value renders differently per message
+    (contains a {token} or is a whole-value generator call)."""
+    return isinstance(value, str) and (
+        "{" in value or _GEN_RE.match(value.strip()) is not None)
+
+
 class PayloadFactory:
     def __init__(self, config: RunConfig, template_store, owner_uid: str,
                  sender_comp_id: str = "", target_comp_id: str = ""):
@@ -81,6 +153,8 @@ class PayloadFactory:
         self._templates: dict[str, dict[int, str]] = {}
         self._order_tpl: Optional[dict[int, str]] = None   # Phase B single-order template
         self._exec_tpl: Optional[dict[int, str]] = None    # Phase B ExecReport template
+        self._gen_rules: dict[int, str] = {}               # tag → expression, every client msg
+        self._counters: dict[int, int] = {}                # seq() state, per tag per run
         self._symbol_i = 0
         self._side_i = 0
         self._load_and_validate()
@@ -89,6 +163,7 @@ class PayloadFactory:
 
     def _load_and_validate(self) -> None:
         vars_ = self.config.payload.variables
+        self._gen_rules = self._parse_gen_rules(vars_)
         for scn in self.config.payload.scenarios:
             seen: list[str] = []
             for tpl_id in scn.messages:
@@ -101,14 +176,32 @@ class PayloadFactory:
                     for tok in _tokens(val):
                         self._validate_token(tok, scn, tpl_id, seen, vars_)
                 seen.append(tpl_id)
+                # gen rules apply to every client-injected message (insert-or-replace)
+                fields.update(self._gen_rules)
 
         # Phase B standalone templates (no scenario sequence → no {ref:}).
         p = self.config.payload
-        self._order_tpl = self._load_standalone(p.order_template_id, _SIMPLE, "order")
+        self._order_tpl = self._load_standalone(p.order_template_id, _SIMPLE, "order",
+                                                merge_rules=True)
         self._exec_tpl = self._load_standalone(p.exec_template_id, _SIMPLE | _EXEC_TOKENS, "exec")
 
-    def _load_standalone(self, tpl_id: Optional[str], allowed: set,
-                         label: str) -> Optional[dict[int, str]]:
+    def _parse_gen_rules(self, vars_: dict) -> dict[int, str]:
+        rules: dict[int, str] = {}
+        for k, v in self.config.payload.gen_rules.items():
+            try:
+                tag = int(k)
+            except (TypeError, ValueError):
+                raise PerfConfigError(f"gen_rules: non-integer tag {k!r}")
+            if tag in CONTROL_TAGS:
+                continue   # transport-owned, the session stamps these
+            val = str(v)
+            for tok in _tokens(val):
+                self._validate_simple_token(tok, f"gen_rules[{tag}]", _SIMPLE, vars_)
+            rules[tag] = val
+        return rules
+
+    def _load_standalone(self, tpl_id: Optional[str], allowed: set, label: str,
+                         merge_rules: bool = False) -> Optional[dict[int, str]]:
         if not tpl_id:
             return None
         tpl = self._ts.get_template(self._uid, tpl_id) if self._ts else None
@@ -118,13 +211,23 @@ class PayloadFactory:
         vars_ = self.config.payload.variables
         for val in fields.values():
             for tok in _tokens(val):
-                if tok.startswith("ref:"):
-                    raise PerfConfigError(
-                        f"{{{tok}}} not allowed in {label} template (no scenario sequence)")
-                if tok not in allowed and tok not in vars_:
-                    raise PerfConfigError(f"unknown token {{{tok}}} in {label} template {tpl_id!r}")
+                self._validate_simple_token(tok, f"{label} template {tpl_id!r}", allowed, vars_)
+        if merge_rules:
+            fields.update(self._gen_rules)
         return fields
 
+    def _validate_simple_token(self, tok: str, where: str, allowed: set, vars_: dict) -> None:
+        """Token check for contexts with no scenario sequence (no {ref:})."""
+        if tok.startswith("ref:"):
+            raise PerfConfigError(f"{{{tok}}} not allowed in {where} (no scenario sequence)")
+        gm = _GEN_RE.match(tok)
+        if gm:
+            if gm.group(1) not in _GENERATOR_NAMES:
+                raise PerfConfigError(f"unknown generator {{{tok}}} in {where}")
+            return
+        if tok not in allowed and tok not in vars_:
+            raise PerfConfigError(f"unknown token {{{tok}}} in {where}")
+
     def _parse_fields(self, tpl: dict, tpl_id: str, label: str = "") -> dict[int, str]:
         try:
             fields = {int(k): str(v) for k, v in tpl.get("fields", {}).items()}
@@ -140,6 +243,11 @@ class PayloadFactory:
                         seen: list[str], vars_: dict) -> None:
         if tok in _SIMPLE or tok in vars_:
             return
+        gm = _GEN_RE.match(tok)
+        if gm:
+            if gm.group(1) not in _GENERATOR_NAMES:
+                raise PerfConfigError(f"unknown generator {{{tok}}} in template {tpl_id!r}")
+            return
         if tok.startswith("ref:"):
             ref = tok[4:]
             if "." not in ref:
@@ -194,6 +302,16 @@ class PayloadFactory:
             msg.set_field(44, f"{ctx['price']:.2f}")
         msg.set_field(59, p.time_in_force)
         msg.set_field(60, _utc_ms())
+        for rtag, raw in self._gen_rules.items():
+            if rtag == self.config.correlation_tag:
+                continue   # engine-authoritative — correlation must survive
+            if rtag == 11 and not _is_dynamic(raw):
+                continue   # a static ClOrdID would repeat across the run
+            val = self._resolve(raw, ctx, corr, clordid, {}, rtag)
+            msg.set_field(rtag, val)
+            if rtag == 11:
+                clordid = val
+        self._apply_expiry(msg, self._gen_rules)
         return msg, {"corr_id": corr, "clordid": clordid, "symbol": ctx["symbol"],
                      "side": ctx["side"], "qty": ctx["qty"], "price": ctx["price"],
                      "order_qty": ctx["qty"], "msg_type": "D"}
@@ -209,22 +327,34 @@ class PayloadFactory:
         for tag, raw in fields.items():
             if tag == 35:
                 continue
-            msg.set_field(tag, self._resolve(raw, ctx, corr, clordid, refs))
+            msg.set_field(tag, self._resolve(raw, ctx, corr, clordid, refs, tag))
         # ensure correlation + clordid are present even if the template omits them
         msg.set_field(self.config.correlation_tag, corr)
-        if 11 not in fields:
+        # ClOrdID must be unique per message: keep a dynamic template value
+        # (renders fresh each time), replace a static one that would repeat.
+        if 11 in fields and _is_dynamic(fields[11]):
+            clordid = msg.get_field_or(11, clordid)
+        else:
             msg.set_field(11, clordid)
+        self._apply_expiry(msg, fields)
         refs[tpl_id] = clordid
         return msg, {"corr_id": corr, "clordid": clordid, "symbol": ctx["symbol"],
                      "side": ctx["side"], "qty": ctx["qty"], "price": ctx["price"],
                      "order_qty": ctx["qty"], "msg_type": mtype}
 
-    def _resolve(self, value: str, ctx: dict, corr: str, clordid: str, refs: dict) -> str:
-        if not isinstance(value, str) or "{" not in value:
+    def _resolve(self, value: str, ctx: dict, corr: str, clordid: str, refs: dict,
+                 tag: int = 0) -> str:
+        if not isinstance(value, str):
             return value
+        if "{" not in value:
+            return _eval_generator(value, tag, self._counters)
 
         def sub(m: re.Match) -> str:
             tok = m.group(1)
+            gm = _GEN_RE.match(tok)
+            if gm:   # embedded generator, e.g. ORD-{seq(8)}
+                out = _gen_call(gm.group(1), gm.group(2), tag, self._counters)
+                return m.group(0) if out is None else out
             if tok == "clordid":
                 return clordid
             if tok in ("compliance_id", "guid"):
@@ -250,11 +380,27 @@ class PayloadFactory:
                 return refs.get(ref_tpl, "")
             return self.config.payload.variables.get(tok, "")
 
-        return _TOKEN_RE.sub(sub, value)
+        return _eval_generator(_TOKEN_RE.sub(sub, value), tag, self._counters)
 
     def _clordid(self) -> str:
         return "PCL-" + _guid()[:12].upper()
 
+    def _apply_expiry(self, msg: Message, fields: dict) -> None:
+        """Rewrite ExpireTime(126)/ExpireDate(432) to a shared future instant —
+        only for tags the message already carries (never inserts), exactly like
+        the standard-send auto-expiry option."""
+        p = self.config.payload
+        if not p.auto_expiry:
+            return
+        has126, has432 = 126 in fields, 432 in fields
+        if not (has126 or has432):
+            return
+        ts = utc_timestamp(offset_s=p.expiry_offset * _EXPIRY_UNIT_S[p.expiry_unit])
+        if has126:
+            msg.set_field(126, ts)
+        if has432:
+            msg.set_field(432, ts[:8])
+
     # -- Phase B: templated single order ------------------------------------
 
     def _build_order_from_template(self, ctx: dict, corr: str, clordid: str) -> tuple[Message, dict]:
@@ -269,12 +415,16 @@ class PayloadFactory:
         for tag, raw in fields.items():
             if tag == 35:
                 continue
-            val = self._resolve(raw, ctx, corr, clordid, {})
+            val = self._resolve(raw, ctx, corr, clordid, {}, tag)
             msg.set_field(tag, val)
             rendered[tag] = val
         # Standard tags the engine depends on (correlation, OrderQty for filling).
         msg.set_field(self.config.correlation_tag, corr)
-        if 11 not in fields:
+        # ClOrdID must be unique per order: keep a dynamic template value
+        # (renders fresh each time), replace a static one that would repeat.
+        if 11 in fields and _is_dynamic(fields[11]):
+            clordid = rendered[11]
+        else:
             msg.set_field(11, clordid)
         if 55 not in fields:
             msg.set_field(55, ctx["symbol"])
@@ -287,6 +437,7 @@ class PayloadFactory:
         else:
             order_qty = ctx["qty"]
             msg.set_field(38, str(order_qty))
+        self._apply_expiry(msg, fields)
         return msg, {"corr_id": corr, "clordid": clordid, "symbol": ctx["symbol"],
                      "side": ctx["side"], "qty": ctx["qty"], "price": ctx["price"],
                      "order_qty": order_qty, "msg_type": mtype}
@@ -313,7 +464,7 @@ class PayloadFactory:
         for tag, raw in self._exec_tpl.items():
             if tag == 35:
                 continue
-            msg.set_field(tag, self._resolve_exec(raw, of, exec_ctx))
+            msg.set_field(tag, self._resolve_exec(raw, of, exec_ctx, tag))
         # Engine-authoritative standard tags (override any template value).
         msg.set_field(cfg.correlation_tag, corr)
         msg.set_field(cfg.exec_id_tag, _uuid())
@@ -337,13 +488,19 @@ class PayloadFactory:
         msg.set_field(60, _utc_ms())
         return msg
 
-    def _resolve_exec(self, value: str, of: dict, exec_ctx: dict) -> str:
-        if not isinstance(value, str) or "{" not in value:
+    def _resolve_exec(self, value: str, of: dict, exec_ctx: dict, tag: int = 0) -> str:
+        if not isinstance(value, str):
             return value
+        if "{" not in value:
+            return _eval_generator(value, tag, self._counters)
         cfg = self.config
 
         def sub(m: re.Match) -> str:
             tok = m.group(1)
+            gm = _GEN_RE.match(tok)
+            if gm:   # embedded generator, e.g. ORD-{seq(8)}
+                out = _gen_call(gm.group(1), gm.group(2), tag, self._counters)
+                return m.group(0) if out is None else out
             if tok in exec_ctx:
                 return str(exec_ctx[tok])
             if tok == "clordid":
@@ -368,7 +525,7 @@ class PayloadFactory:
                 return "E" + _guid()[:8].upper()
             return cfg.payload.variables.get(tok, "")
 
-        return _TOKEN_RE.sub(sub, value)
+        return _eval_generator(_TOKEN_RE.sub(sub, value), tag, self._counters)
 
 
 class ScenarioSelector: