fixtureqa 0.10.4__tar.gz → 0.11.0__tar.gz

{fixtureqa-0.10.4/fixtureqa.egg-info → fixtureqa-0.11.0}/PKG-INFO

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

{fixtureqa-0.10.4 → fixtureqa-0.11.0}/fixture/core/perf_engine.py

@@ -868,7 +868,7 @@ class PerfRun:
     def _exec(self, of: dict, **kw) -> Optional[Message]:
         """Build one ExecReport via the exec template when configured, else the
         built-in builder (Phase B). Both enforce the standard correlation tags."""
-        if self.config.payload.exec_template_id:
+        if self._factory.has_exec_template:
             return self._factory.build_exec_message(of, **kw)
         return self._build_exec(of, **kw)
 

{fixtureqa-0.10.4 → fixtureqa-0.11.0}/fixture/core/perf_models.py

@@ -175,10 +175,14 @@ class PayloadConfig(BaseModel):
     fill: FillPayloadConfig = Field(default_factory=FillPayloadConfig)
     scenarios: list[ScenarioConfig] = Field(default_factory=list)
     # Phase B — optional TemplateStore template ids (resolved for the run's owner).
-    # order_template_id shapes single-order injection (ignored when scenarios are set);
-    # 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
+    # The *_ids lists shape single-order injection / the venue's ack-fill ExecReports;
+    # when more than one is given the engine round-robins them per order / per report.
+    # Empty → built-in builders. The singular *_id fields are the legacy one-template
+    # form kept for old saved configs; _fold_template_ids merges them into the lists.
+    order_template_ids: list[str] = Field(default_factory=list)
+    exec_template_ids: list[str] = Field(default_factory=list)
+    order_template_id: Optional[str] = None   # deprecated — folded into order_template_ids
+    exec_template_id: Optional[str] = None     # deprecated — folded into exec_template_ids
     # 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
@@ -194,6 +198,21 @@ class PayloadConfig(BaseModel):
             raise ValueError("scenario weights must be > 0")
         return self
 
+    @model_validator(mode="after")
+    def _fold_template_ids(self) -> "PayloadConfig":
+        # Old saved configs / API clients send the singular order_template_id /
+        # exec_template_id; fold those into the lists so the engine only reads
+        # the lists. Drop blanks and de-dup while preserving order.
+        if not self.order_template_ids and self.order_template_id:
+            self.order_template_ids = [self.order_template_id]
+        if not self.exec_template_ids and self.exec_template_id:
+            self.exec_template_ids = [self.exec_template_id]
+        self.order_template_ids = [t for t in dict.fromkeys(self.order_template_ids) if t]
+        self.exec_template_ids = [t for t in dict.fromkeys(self.exec_template_ids) if t]
+        self.order_template_id = self.order_template_ids[0] if self.order_template_ids else None
+        self.exec_template_id = self.exec_template_ids[0] if self.exec_template_ids else None
+        return self
+
 
 class RelayConfig(BaseModel):
     """middle_manager relay behaviour. Verbatim forward by default; an optional

{fixtureqa-0.10.4 → fixtureqa-0.11.0}/fixture/core/perf_payload.py

@@ -127,8 +127,12 @@ class PayloadFactory:
         self._sender = sender_comp_id
         self._target = target_comp_id
         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
+        # Phase B standalone templates — one or more order / ExecReport specs,
+        # round-robined per order / per report when more than one is configured.
+        self._order_tpls: list[dict[int, str]] = []
+        self._exec_tpls: list[dict[int, str]] = []
+        self._order_tpl_i = 0
+        self._exec_tpl_i = 0
         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
@@ -157,9 +161,10 @@ class PayloadFactory:
 
         # 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",
-                                                merge_rules=True)
-        self._exec_tpl = self._load_standalone(p.exec_template_id, _SIMPLE | _EXEC_TOKENS, "exec")
+        self._order_tpls = [self._load_standalone(tid, _SIMPLE, "order", merge_rules=True)
+                            for tid in p.order_template_ids]
+        self._exec_tpls = [self._load_standalone(tid, _SIMPLE | _EXEC_TOKENS, "exec")
+                           for tid in p.exec_template_ids]
 
     def _parse_gen_rules(self, vars_: dict) -> dict[int, str]:
         rules: dict[int, str] = {}
@@ -238,6 +243,26 @@ class PayloadFactory:
             return
         raise PerfConfigError(f"unknown token {{{tok}}} in template {tpl_id!r}")
 
+    # -- standalone template selection (round-robin) -------------------
+
+    @property
+    def has_order_template(self) -> bool:
+        return bool(self._order_tpls)
+
+    @property
+    def has_exec_template(self) -> bool:
+        return bool(self._exec_tpls)
+
+    def _next_order_tpl(self) -> dict[int, str]:
+        tpl = self._order_tpls[self._order_tpl_i % len(self._order_tpls)]
+        self._order_tpl_i += 1
+        return tpl
+
+    def _next_exec_tpl(self) -> dict[int, str]:
+        tpl = self._exec_tpls[self._exec_tpl_i % len(self._exec_tpls)]
+        self._exec_tpl_i += 1
+        return tpl
+
     # -- order context (per scenario instance / per single order) ------
 
     def new_context(self) -> dict:
@@ -262,8 +287,8 @@ class PayloadFactory:
     def build_single_order(self) -> tuple[Message, dict]:
         ctx = self.new_context()
         corr, clordid = _uuid(), self._clordid()
-        if self._order_tpl is not None:
-            return self._build_order_from_template(ctx, corr, clordid)
+        if self._order_tpls:
+            return self._build_order_from_template(self._next_order_tpl(), ctx, corr, clordid)
         p = self.config.payload.order
         is_market = p.ord_type == "market"
         msg = Message()
@@ -437,11 +462,11 @@ class PayloadFactory:
 
     # -- Phase B: templated single order ------------------------------------
 
-    def _build_order_from_template(self, ctx: dict, corr: str, clordid: str) -> tuple[Message, dict]:
-        """Render the order template, then ensure the standard tags the venue and
+    def _build_order_from_template(self, fields: dict[int, str], ctx: dict,
+                                   corr: str, clordid: str) -> tuple[Message, dict]:
+        """Render one order template, then ensure the standard tags the venue and
         correlator need are present (injected from ctx when the template omits them),
         so an authored order spec can never break filling/correlation."""
-        fields = self._order_tpl
         mtype = fields.get(35, "D")
         msg = Message()
         msg.header.set(35, mtype)
@@ -501,7 +526,7 @@ class PayloadFactory:
         }
         msg = Message()
         msg.header.set(35, "8")
-        for tag, raw in self._exec_tpl.items():
+        for tag, raw in self._next_exec_tpl().items():
             if tag == 35:
                 continue
             msg.set_field(tag, self._resolve_exec(raw, of, exec_ctx, tag))