simudyne-pulse 0.7.0.dev7__tar.gz → 0.7.0.dev9__tar.gz

{simudyne_pulse-0.7.0.dev7/src/simudyne_pulse.egg-info → simudyne_pulse-0.7.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simudyne-pulse
-Version: 0.7.0.dev7
+Version: 0.7.0.dev9
 Summary: Python SDK for the Simudyne Pulse synthetic market data API
 Author-email: Simudyne <support@simudyne.com>
 License-Expression: MIT
@@ -59,6 +59,84 @@ pip install --pre simudyne-pulse
 Only use dev builds for testing unreleased changes; they are not guaranteed
 stable. Merge `dev` into `prod` to promote those changes to a stable release.
 
+### Comparing named populations
+
+Simulations are often not one population but several — a foundation model and
+an ABM, or two versions of a model. Name them and the results compare them
+instead of averaging them together:
+
+```python
+job = client.validation.run(
+    symbol="TSCO", date="2026-06-23", provider="bmll", exchange="lse",
+    sim_ids={"fm": fm_ids, "abm": abm_ids},
+    plots=["statistical.radar", "stylised_facts.overall",
+           "volume_correlation.overall"],
+)
+result = client.validation.get_job(job["job_id"], plot_dir="figs")
+result["distances"]["fm"]["spread"]["l1"]
+result["stylised_fact_verdicts"]["heavy_tails"]["simulated"]["abm"]
+```
+
+`distances`, `distributions`, the verdicts and the FID/MIND scores come back
+keyed by name; the radar draws a polygon per population, the verdict table a
+column each, and volume correlation puts historical first then a heatmap per
+population. `sim_files` groups the same way.
+
+A plain list is one unnamed population and keeps the flat shape exactly as
+before. The historical day is measured once however many groups there are.
+
+`plot_all=True` draws everything the enabled areas can draw, not just the
+summaries.
+
+### Working from a checkout
+
+To run the SDK from source — editing it, or using unreleased changes — install
+it editable **into the interpreter you will actually import from**. A notebook
+kernel is frequently not the python on your `$PATH`:
+
+```bash
+# in a notebook, find the right interpreter first
+import sys; print(sys.executable)
+
+# then, with that path
+<that python> -m pip install -e /path/to/pulse-sdk
+```
+
+Check which copy you loaded — this is worth doing whenever an attribute seems
+to be missing:
+
+```python
+import simudyne
+from importlib.metadata import version
+
+print(simudyne.__file__)          # should be .../pulse-sdk/src/simudyne/...
+print(version("simudyne-pulse"))
+```
+
+#### If an older install shadows it
+
+The SDK was once published under the distribution name **`simudyne`**; it is
+now **`simudyne-pulse`**. Both ship a module called `simudyne`, and the older
+one installs a real directory while the editable install only adds a path
+entry — so the old copy wins and you get errors like
+`'PulseABM' object has no attribute 'validation'` from a version that predates
+the feature. `pip list` shows both. Remove the obsolete one:
+
+```bash
+<that python> -m pip uninstall simudyne      # the old distribution
+<that python> -m pip install -e /path/to/pulse-sdk
+```
+
+### Running the tests
+
+```bash
+uv run --with pytest --with requests --with pandas --with pyarrow \
+    python -m pytest tests/ -q
+```
+
+No network: the client's `_request` is replaced with a recorder, so the tests
+assert the exact payload the API would receive.
+
 ## Quick start
 
 ```python

{simudyne_pulse-0.7.0.dev7 → simudyne_pulse-0.7.0.dev9}/README.md

@@ -33,6 +33,84 @@ pip install --pre simudyne-pulse
 Only use dev builds for testing unreleased changes; they are not guaranteed
 stable. Merge `dev` into `prod` to promote those changes to a stable release.
 
+### Comparing named populations
+
+Simulations are often not one population but several — a foundation model and
+an ABM, or two versions of a model. Name them and the results compare them
+instead of averaging them together:
+
+```python
+job = client.validation.run(
+    symbol="TSCO", date="2026-06-23", provider="bmll", exchange="lse",
+    sim_ids={"fm": fm_ids, "abm": abm_ids},
+    plots=["statistical.radar", "stylised_facts.overall",
+           "volume_correlation.overall"],
+)
+result = client.validation.get_job(job["job_id"], plot_dir="figs")
+result["distances"]["fm"]["spread"]["l1"]
+result["stylised_fact_verdicts"]["heavy_tails"]["simulated"]["abm"]
+```
+
+`distances`, `distributions`, the verdicts and the FID/MIND scores come back
+keyed by name; the radar draws a polygon per population, the verdict table a
+column each, and volume correlation puts historical first then a heatmap per
+population. `sim_files` groups the same way.
+
+A plain list is one unnamed population and keeps the flat shape exactly as
+before. The historical day is measured once however many groups there are.
+
+`plot_all=True` draws everything the enabled areas can draw, not just the
+summaries.
+
+### Working from a checkout
+
+To run the SDK from source — editing it, or using unreleased changes — install
+it editable **into the interpreter you will actually import from**. A notebook
+kernel is frequently not the python on your `$PATH`:
+
+```bash
+# in a notebook, find the right interpreter first
+import sys; print(sys.executable)
+
+# then, with that path
+<that python> -m pip install -e /path/to/pulse-sdk
+```
+
+Check which copy you loaded — this is worth doing whenever an attribute seems
+to be missing:
+
+```python
+import simudyne
+from importlib.metadata import version
+
+print(simudyne.__file__)          # should be .../pulse-sdk/src/simudyne/...
+print(version("simudyne-pulse"))
+```
+
+#### If an older install shadows it
+
+The SDK was once published under the distribution name **`simudyne`**; it is
+now **`simudyne-pulse`**. Both ship a module called `simudyne`, and the older
+one installs a real directory while the editable install only adds a path
+entry — so the old copy wins and you get errors like
+`'PulseABM' object has no attribute 'validation'` from a version that predates
+the feature. `pip list` shows both. Remove the obsolete one:
+
+```bash
+<that python> -m pip uninstall simudyne      # the old distribution
+<that python> -m pip install -e /path/to/pulse-sdk
+```
+
+### Running the tests
+
+```bash
+uv run --with pytest --with requests --with pandas --with pyarrow \
+    python -m pytest tests/ -q
+```
+
+No network: the client's `_request` is replaced with a recorder, so the tests
+assert the exact payload the API would receive.
+
 ## Quick start
 
 ```python

{simudyne_pulse-0.7.0.dev7 → simudyne_pulse-0.7.0.dev9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simudyne-pulse"
-version = "0.7.0-dev.7"
+version = "0.7.0-dev.9"
 description = "Python SDK for the Simudyne Pulse synthetic market data API"
 readme = "README.md"
 license = "MIT"

{simudyne_pulse-0.7.0.dev7 → simudyne_pulse-0.7.0.dev9}/src/simudyne/resources/validation.py

@@ -64,7 +64,8 @@ _AREA_FLAGS = (
 #: needing the message stream; ``sample_period`` and ``match_generated_sample``
 #: set the grid the book is resampled onto; ``plots`` is False, True, or a list
 #: of plot ids.
-_EXTRA_FIELDS = ("lob", "sample_period", "match_generated_sample", "plots")
+_EXTRA_FIELDS = ("lob", "sample_period", "match_generated_sample", "plots",
+                 "plot_all")
 
 
 def _frame_to_parquet(entry, index: int):
@@ -172,6 +173,7 @@ class ValidationResource:
         match_generated_sample=None,
         n_levels: int = 10,
         plots=None,
+        plot_all: bool = False,
     ) -> dict:
         """Submit a validation job.
 
@@ -192,13 +194,17 @@ class ValidationResource:
             ``(symbol, provider, exchange)`` is the identity, not the symbol.
         exchange : str
             Exchange, e.g. ``"lse"`` or ``"hkex_securities"``.
-        sim_ids : list of str, optional
-            Platform simulation IDs, 1 to 25. Exactly one of ``sim_ids`` or
-            ``sim_files`` is required.
-        sim_files : list, optional
+        sim_ids : list of str or dict, optional
+            Platform simulation IDs, 1 to 25. A flat list is one unnamed
+            population. A mapping — ``{"fm": [...], "abm": [...]}`` — compares
+            the named populations: distances, distributions, verdicts and
+            FID/MIND scores come back keyed by name, and the summary figures
+            draw one series per name instead of averaging them together.
+            Exactly one of ``sim_ids`` or ``sim_files`` is required.
+        sim_files : list or dict, optional
             Your own simulated runs, up to 25: paths, ``(filename, bytes)``
-            pairs, or polars / pandas DataFrames in pulse format. The
-            historical side is fetched for you.
+            pairs, or polars / pandas DataFrames in pulse format. Grouped the
+            same way as ``sim_ids``. The historical side is fetched for you.
         ticksize : float, default 1.0
             Minimum price increment. Should match the instrument.
         statistical, stylised_facts, impact, volume_correlation, fid, mind : bool, optional
@@ -221,6 +227,10 @@ class ValidationResource:
             ``None`` or ``False`` for none, ``True`` for every figure, or plot
             ids such as ``["statistical.radar", "stylised_facts.overall"]``.
             Rendered server-side; :meth:`get_job` writes them to disk.
+        plot_all : bool, default False
+            Draw everything the enabled areas can draw — every distribution and
+            every stylised fact, not just the summaries. An area switched off
+            still draws nothing, so this means "all of what ran".
 
         Returns
         -------
@@ -239,7 +249,12 @@ class ValidationResource:
             raise ValueError("sim_ids must not be empty")
         if sim_files is not None and not sim_files:
             raise ValueError("sim_files must not be empty")
-        count = len(sim_ids if sim_ids is not None else sim_files)
+        given = sim_ids if sim_ids is not None else sim_files
+        count = (
+            sum(len(v) for v in given.values())
+            if isinstance(given, dict)
+            else len(given)
+        )
         if count > MAX_SIM_FILES:
             raise ValueError(f"Maximum {MAX_SIM_FILES} simulations per validation job")
         if ticksize <= 0:
@@ -259,6 +274,7 @@ class ValidationResource:
             sample_period=sample_period,
             match_generated_sample=match_generated_sample,
             plots=plots,
+            plot_all=plot_all or None,
         )
 
         if sim_ids is not None:
@@ -270,16 +286,36 @@ class ValidationResource:
                     "date": date,
                     "provider": provider,
                     "exchange": exchange,
-                    "sim_ids": list(sim_ids),
+                    "sim_ids": (
+                        {k: list(v) for k, v in sim_ids.items()}
+                        if isinstance(sim_ids, dict)
+                        else list(sim_ids)
+                    ),
                     "ticksize": ticksize,
                     "config": config,
                 },
             )
         else:
+            # Three-tuple parts: the content type matters to the server's
+            # multipart parser, so it is sent explicitly.
+            # Grouped uploads travel flat with the grouping beside them, the
+            # same way sim_ids do — multipart has no nesting.
+            if isinstance(sim_files, dict):
+                flat, groups, offset = [], {}, 0
+                for name, runs in sim_files.items():
+                    runs = list(runs)
+                    groups[name] = list(range(offset, offset + len(runs)))
+                    offset += len(runs)
+                    flat.extend(runs)
+            else:
+                flat, groups = list(sim_files), None
+
             files = [
-                ("sim_files", _frame_to_parquet(entry, i))
-                for i, entry in enumerate(sim_files)
+                ("sim_files", (*_frame_to_parquet(entry, i), "application/octet-stream"))
+                for i, entry in enumerate(flat)
             ]
+            if groups:
+                config = {**config, "sim_groups": groups}
             submitted = self._client._request(
                 "POST",
                 UPLOAD_PATH,

{simudyne_pulse-0.7.0.dev7 → simudyne_pulse-0.7.0.dev9/src/simudyne_pulse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simudyne-pulse
-Version: 0.7.0.dev7
+Version: 0.7.0.dev9
 Summary: Python SDK for the Simudyne Pulse synthetic market data API
 Author-email: Simudyne <support@simudyne.com>
 License-Expression: MIT
@@ -59,6 +59,84 @@ pip install --pre simudyne-pulse
 Only use dev builds for testing unreleased changes; they are not guaranteed
 stable. Merge `dev` into `prod` to promote those changes to a stable release.
 
+### Comparing named populations
+
+Simulations are often not one population but several — a foundation model and
+an ABM, or two versions of a model. Name them and the results compare them
+instead of averaging them together:
+
+```python
+job = client.validation.run(
+    symbol="TSCO", date="2026-06-23", provider="bmll", exchange="lse",
+    sim_ids={"fm": fm_ids, "abm": abm_ids},
+    plots=["statistical.radar", "stylised_facts.overall",
+           "volume_correlation.overall"],
+)
+result = client.validation.get_job(job["job_id"], plot_dir="figs")
+result["distances"]["fm"]["spread"]["l1"]
+result["stylised_fact_verdicts"]["heavy_tails"]["simulated"]["abm"]
+```
+
+`distances`, `distributions`, the verdicts and the FID/MIND scores come back
+keyed by name; the radar draws a polygon per population, the verdict table a
+column each, and volume correlation puts historical first then a heatmap per
+population. `sim_files` groups the same way.
+
+A plain list is one unnamed population and keeps the flat shape exactly as
+before. The historical day is measured once however many groups there are.
+
+`plot_all=True` draws everything the enabled areas can draw, not just the
+summaries.
+
+### Working from a checkout
+
+To run the SDK from source — editing it, or using unreleased changes — install
+it editable **into the interpreter you will actually import from**. A notebook
+kernel is frequently not the python on your `$PATH`:
+
+```bash
+# in a notebook, find the right interpreter first
+import sys; print(sys.executable)
+
+# then, with that path
+<that python> -m pip install -e /path/to/pulse-sdk
+```
+
+Check which copy you loaded — this is worth doing whenever an attribute seems
+to be missing:
+
+```python
+import simudyne
+from importlib.metadata import version
+
+print(simudyne.__file__)          # should be .../pulse-sdk/src/simudyne/...
+print(version("simudyne-pulse"))
+```
+
+#### If an older install shadows it
+
+The SDK was once published under the distribution name **`simudyne`**; it is
+now **`simudyne-pulse`**. Both ship a module called `simudyne`, and the older
+one installs a real directory while the editable install only adds a path
+entry — so the old copy wins and you get errors like
+`'PulseABM' object has no attribute 'validation'` from a version that predates
+the feature. `pip list` shows both. Remove the obsolete one:
+
+```bash
+<that python> -m pip uninstall simudyne      # the old distribution
+<that python> -m pip install -e /path/to/pulse-sdk
+```
+
+### Running the tests
+
+```bash
+uv run --with pytest --with requests --with pandas --with pyarrow \
+    python -m pytest tests/ -q
+```
+
+No network: the client's `_request` is replaced with a recorder, so the tests
+assert the exact payload the API would receive.
+
 ## Quick start
 
 ```python

{simudyne_pulse-0.7.0.dev7 → simudyne_pulse-0.7.0.dev9}/src/simudyne_pulse.egg-info/SOURCES.txt

@@ -19,6 +19,10 @@ src/simudyne_pulse.egg-info/SOURCES.txt
 src/simudyne_pulse.egg-info/dependency_links.txt
 src/simudyne_pulse.egg-info/requires.txt
 src/simudyne_pulse.egg-info/top_level.txt
+tests/test_endpoint_coverage.py
+tests/test_fix.py
+tests/test_fm.py
 tests/test_new_resources.py
+tests/test_run_lrm.py
 tests/test_simulator_gym.py
 tests/test_validation.py

simudyne_pulse-0.7.0.dev9/tests/test_endpoint_coverage.py

@@ -0,0 +1,142 @@
+"""Tests for the wrappers added to close the gap against pulse-api-pod.
+
+Each of these existed as an endpoint the SDK could not reach, so the point of
+the test is that the SDK now targets the right path with the right shape --
+including the two that do not return JSON or do not send JSON.
+"""
+
+import json
+
+import pytest
+
+from simudyne.resources.data import AVAILABLE_SYMBOLS_PATH, DataResource
+from simudyne.resources.simulation import JOBS_PATH, SimulationResource
+from simudyne.resources.validation import UPLOAD_PATH, ValidationResource
+
+
+class FakeClient:
+    base_url = "https://api.example.test"
+
+    def __init__(self, text="", json_body=None):
+        self.calls = []
+        self._text = text
+        self._json = json_body or {}
+
+    def _request(self, method, path, **kwargs):
+        self.calls.append((method, path, kwargs))
+        return self._json
+
+    def _request_text(self, method, path, **kwargs):
+        self.calls.append((method, path, kwargs))
+        return self._text
+
+    def _request_with_retries(self, method, url, **kwargs):
+        self.calls.append((method, url, kwargs))
+
+        class _Resp:
+            @staticmethod
+            def json():
+                return {"job_id": "v1", "status": "pending", "message": "ok"}
+
+        return _Resp()
+
+    @property
+    def last(self):
+        return self.calls[-1]
+
+
+class TestJobLogs:
+    def test_returns_text_not_json(self):
+        client = FakeClient(text="engine boot\nsim 0000 complete\n")
+        res = SimulationResource(client)
+        out = res.get_job_logs("job-1")
+        # text/plain endpoint: _request would raise on .json(), so the resource
+        # must route through _request_text
+        assert isinstance(out, str)
+        assert "sim 0000 complete" in out
+        assert client.last[:2] == ("GET", f"{JOBS_PATH}/job-1/logs")
+
+
+class TestGetJobsLimit:
+    def test_limit_is_omitted_by_default(self):
+        client = FakeClient()
+        SimulationResource(client).get_jobs()
+        assert client.last[2]["params"] is None
+
+    def test_limit_is_forwarded(self):
+        client = FakeClient()
+        SimulationResource(client).get_jobs(limit=250)
+        assert client.last[2]["params"] == {"limit": 250}
+
+
+class TestSymbolSearch:
+    def test_q_is_sent_and_is_separate_from_symbol(self):
+        client = FakeClient(json_body=[])
+        DataResource(client).get_available_symbols(q="tenc")
+        method, path, kwargs = client.last
+        assert (method, path) == ("GET", AVAILABLE_SYMBOLS_PATH)
+        assert kwargs["params"] == {"q": "tenc"}
+
+    def test_no_filters_sends_no_params(self):
+        client = FakeClient(json_body=[])
+        DataResource(client).get_available_symbols()
+        assert client.last[2]["params"] is None
+
+
+class TestValidationUpload:
+    def _files(self, tmp_path, n):
+        paths = []
+        for i in range(n):
+            p = tmp_path / f"sim_{i:04d}.parquet"
+            p.write_bytes(b"PAR1fake")
+            paths.append(p)
+        return paths
+
+    def test_posts_multipart_with_config_as_json_string(self, tmp_path):
+        client = FakeClient(json_body={"job_id": "v1"})
+        res = ValidationResource(client)
+        out = res.run(
+            symbol="700.HK", date="2025-09-02",
+            provider="omd", exchange="hkex_securities",
+            sim_files=self._files(tmp_path, 2),
+        )
+        method, url, kwargs = client.last
+        assert method == "POST" and url.endswith(UPLOAD_PATH)
+        assert len(kwargs["files"]) == 2
+        assert all(f[0] == "sim_files" for f in kwargs["files"])
+        # multipart form fields must be strings, and config a JSON string
+        data = kwargs["data"]
+        assert data["ticksize"] == "1.0"
+        assert "run_fid" not in json.loads(data["config"])
+        assert out["job_id"] == "v1"
+
+    def test_tri_state_flags_are_omitted_from_the_config_string(self, tmp_path):
+        client = FakeClient(json_body={"job_id": "v1"})
+        ValidationResource(client).run(
+            symbol="700.HK", date="2025-09-02",
+            provider="omd", exchange="hkex_securities",
+            sim_files=self._files(tmp_path, 1),
+        )
+        config = json.loads(client.last[2]["data"]["config"])
+        for flag in ("run_metrics", "run_impact", "run_stylised_facts",
+                     "plot_data", "run_fid", "statistical", "fid", "mind"):
+            assert flag not in config
+
+    def test_accepts_in_memory_pairs(self, tmp_path):
+        client = FakeClient(json_body={"job_id": "v1"})
+        ValidationResource(client).run(
+            symbol="700.HK", date="2025-09-02",
+            provider="omd", exchange="hkex_securities",
+            sim_files=[("sim_0000.parquet", b"PAR1fake")],
+        )
+        name, content, mime = client.last[2]["files"][0][1]
+        assert name == "sim_0000.parquet" and content == b"PAR1fake"
+
+    def test_rejects_empty_and_oversized_batches(self, tmp_path):
+        res = ValidationResource(FakeClient())
+        common = dict(symbol="700.HK", date="2025-09-02",
+                      provider="omd", exchange="hkex_securities")
+        with pytest.raises(ValueError, match="must not be empty"):
+            res.run(sim_files=[], **common)
+        with pytest.raises(ValueError, match="25"):
+            res.run(sim_files=self._files(tmp_path, 26), **common)

simudyne_pulse-0.7.0.dev9/tests/test_fix.py

@@ -0,0 +1,35 @@
+"""Tests for the FIX usage wrapper.
+
+The venue is raw TCP and not reachable from this SDK; this is the one HTTP
+endpoint a FIX client needs, so all there is to pin is the path and the
+admin-only user_id passthrough.
+"""
+
+from simudyne.resources.fix import USAGE_PATH, FixResource
+
+
+class FakeClient:
+    def __init__(self):
+        self.calls = []
+
+    def _request(self, method, path, **kwargs):
+        self.calls.append((method, path, kwargs))
+        return {"total_runs": 3, "runs": []}
+
+    @property
+    def last(self):
+        return self.calls[-1]
+
+
+def test_own_usage_sends_no_params():
+    client = FakeClient()
+    out = FixResource(client).usage()
+    assert client.last[:2] == ("GET", USAGE_PATH)
+    assert client.last[2]["params"] is None
+    assert out["total_runs"] == 3
+
+
+def test_user_id_is_forwarded_for_admin_reads():
+    client = FakeClient()
+    FixResource(client).usage(user_id="user_abc")
+    assert client.last[2]["params"] == {"user_id": "user_abc"}

simudyne_pulse-0.7.0.dev9/tests/test_fm.py

@@ -0,0 +1,144 @@
+"""Tests for the foundation-model resource's requests.
+
+No network: the client's _request is a recorder, so these assert the exact
+query and body the API receives. The FM contract is easy to get subtly wrong
+-- duration_minutes supersedes horizon, n_runs is capped server-side, and
+model_args keys are rejected rather than ignored -- so the payload shape is
+what is worth pinning.
+"""
+
+import pytest
+
+from simudyne.resources.fm import (
+    AVAILABLE_DATA_PATH,
+    JOBS_PATH,
+    LIVE_PATH,
+    MODELS_PATH,
+    RUN_PATH,
+    TERMINAL_STATUSES,
+    FmResource,
+)
+
+
+class FakeClient:
+    def __init__(self, responses=None):
+        self.calls = []
+        self._responses = list(responses or [])
+
+    def _request(self, method, path, **kwargs):
+        self.calls.append((method, path, kwargs))
+        return self._responses.pop(0) if self._responses else {}
+
+    @property
+    def last(self):
+        return self.calls[-1]
+
+
+@pytest.fixture
+def fm():
+    res = FmResource(FakeClient())
+    return res
+
+
+class TestDiscovery:
+    def test_models_hits_the_models_path(self, fm):
+        fm.models()
+        method, path, _ = fm._client.last
+        assert (method, path) == ("GET", MODELS_PATH)
+
+    def test_models_returns_the_api_shape_unchanged(self):
+        # The endpoint answers {"models": [...]}, not a bare list. Returning it
+        # verbatim keeps every resource method consistent -- raw JSON through.
+        client = FakeClient(responses=[{"models": [{"model_id": "m1"}]}])
+        out = FmResource(client).models()
+        assert out["models"][0]["model_id"] == "m1"
+
+    def test_available_data_omits_unset_filters(self, fm):
+        fm.available_data()
+        _, path, kwargs = fm._client.last
+        assert path == AVAILABLE_DATA_PATH
+        # limit/offset have real defaults and are always sent; nothing else is
+        assert kwargs["params"] == {"limit": 50, "offset": 0}
+
+    def test_available_data_passes_model_id_so_markets_are_filtered(self, fm):
+        fm.available_data(model_id="tradefm-hkex", q="700", date="2025-09-02")
+        params = fm._client.last[2]["params"]
+        assert params["model_id"] == "tradefm-hkex"
+        assert params["q"] == "700"
+        assert params["date"] == "2025-09-02"
+
+
+class TestRunPayload:
+    def _run(self, fm, **kw):
+        base = dict(
+            model_id="tradefm-hkex",
+            symbol="700",
+            cal_date="2025-09-02",
+            provider="bmll",
+            exchange="hkex_securities",
+        )
+        base.update(kw)
+        fm.run(**base)
+        return fm._client.last[2]["json"]
+
+    def test_targets_run_path_with_required_defaults(self, fm):
+        body = self._run(fm)
+        assert fm._client.last[:2] == ("POST", RUN_PATH)
+        assert body["model_id"] == "tradefm-hkex"
+        assert body["n_runs"] == 1
+        assert body["seed"] == 42
+
+    def test_unset_optionals_are_omitted_not_nulled(self, fm):
+        body = self._run(fm)
+        for field in ("duration_minutes", "horizon", "device", "prompt",
+                      "model_args", "exec_algos"):
+            assert field not in body, f"{field} must be omitted when unset"
+
+    def test_duration_and_horizon_are_both_forwarded_when_given(self, fm):
+        # The API decides precedence (duration_minutes wins); the SDK must not
+        # silently drop one, or a caller cannot express the legacy form.
+        body = self._run(fm, duration_minutes=30, horizon=500)
+        assert body["duration_minutes"] == 30
+        assert body["horizon"] == 500
+
+    def test_model_args_pass_through(self, fm):
+        body = self._run(fm, model_args={"temperature": 0.8})
+        assert body["model_args"] == {"temperature": 0.8}
+
+    def test_empty_model_args_is_omitted(self, fm):
+        body = self._run(fm, model_args={})
+        assert "model_args" not in body
+
+    def test_css_exec_algo_orders_are_serialized_like_the_abm(self, fm):
+        pd = pytest.importorskip("pandas")
+        idx = pd.date_range("2025-09-02 09:30", periods=3, freq="1min")
+        orders = pd.Series([10, 20, 30], index=idx)
+        body = self._run(fm, exec_algos=[{"type": "css", "orders": orders}])
+        sent = body["exec_algos"][0]["orders"]
+        # A pd.Series is not JSON-serializable; it must arrive as str -> int
+        assert isinstance(sent, dict)
+        assert all(isinstance(k, str) and isinstance(v, int) for k, v in sent.items())
+        assert sum(sent.values()) == 60
+
+
+class TestJobsAndLive:
+    def test_job_status_path(self, fm):
+        fm.job_status("job-1")
+        assert fm._client.last[:2] == ("GET", f"{JOBS_PATH}/job-1/status")
+
+    def test_job_logs_path(self, fm):
+        fm.job_logs("job-1")
+        assert fm._client.last[:2] == ("GET", f"{JOBS_PATH}/job-1/logs")
+
+    def test_live_targets_live_path_and_omits_unset(self, fm):
+        fm.live(model_id="tradefm-hkex")
+        method, path, kwargs = fm._client.last
+        assert (method, path) == ("POST", LIVE_PATH)
+        assert kwargs["json"] == {"model_id": "tradefm-hkex", "seed": 42}
+
+    def test_only_complete_and_failed_are_terminal(self):
+        # A poller loops on "not terminal", so a new waiting state must not
+        # accidentally read as finished.
+        assert set(TERMINAL_STATUSES) == {"complete", "failed"}
+        for waiting in ("queued", "provisioning", "starting", "running"):
+            assert waiting not in TERMINAL_STATUSES

{simudyne_pulse-0.7.0.dev7 → simudyne_pulse-0.7.0.dev9}/tests/test_new_resources.py

@@ -1,4 +1,4 @@
-"""Payload tests for the 0.8.0 surface: validation.run_upload, the fm and fix
+"""Payload tests for the 0.8.0 surface: validation.run, the fm and fix
 resources, and simulation.get_job_logs / run_lrm.
 
 No network — same recorder pattern as test_validation.py. These pin the wire
@@ -30,7 +30,7 @@ class TestRunUpload:
     def test_rejects_empty_before_any_request(self):
         client = FakeClient()
         with pytest.raises(ValueError, match="empty"):
-            ValidationResource(client).run_upload(
+            ValidationResource(client).run(
                 "700.HK", "2025-09-01", "omd", "hkex_securities", sim_files=[]
             )
         assert client.calls == []
@@ -39,18 +39,18 @@ class TestRunUpload:
         client = FakeClient()
         files = [(f"sim_{i}.parquet", b"x") for i in range(26)]
         with pytest.raises(ValueError, match="25"):
-            ValidationResource(client).run_upload(
+            ValidationResource(client).run(
                 "700.HK", "2025-09-01", "omd", "hkex_securities", sim_files=files
             )
         assert client.calls == []
 
     def test_multipart_payload_shape(self):
         client = FakeClient([{"job_id": "v1", "status": "pending"}])
-        ValidationResource(client).run_upload(
+        ValidationResource(client).run(
             "700.HK", "2025-09-01", "omd", "hkex_securities",
             sim_files=[("sim_0000.parquet", b"PARQ")],
             ticksize=0.5,
-            run_metrics=False,
+            statistical=False,
         )
         method, path, kwargs = client.calls[0]
         assert (method, path) == ("POST", "/validation/run/upload")
@@ -58,11 +58,11 @@ class TestRunUpload:
         assert data["provider"] == "omd" and data["exchange"] == "hkex_securities"
         assert data["ticksize"] == "0.5"
         config = json.loads(data["config"])
-        # explicit False sent; unset tri-state flags omitted (tier default)
-        assert config["run_metrics"] is False
-        for flag in ("run_impact", "run_stylised_facts", "plot_data"):
+        # explicit False sent; unset area flags omitted (tier default)
+        assert config["statistical"] is False
+        for flag in ("impact", "stylised_facts", "fid", "mind",
+                     "run_metrics", "plot_data"):
             assert flag not in config
-        assert config["run_fid"] is True
         [(field, (filename, content, mime))] = kwargs["files"]
         assert field == "sim_files" and filename == "sim_0000.parquet"
         assert content == b"PARQ" and mime == "application/octet-stream"
@@ -70,8 +70,8 @@ class TestRunUpload:
     def test_reads_paths_from_disk(self, tmp_path):
         p = tmp_path / "sim_0001.parquet"
         p.write_bytes(b"BYTES")
-        client = FakeClient([{}])
-        ValidationResource(client).run_upload(
+        client = FakeClient([{"job_id": "v1"}])
+        ValidationResource(client).run(
             "700.HK", "2025-09-01", "omd", "hkex_securities", sim_files=[p]
         )
         [(_, (filename, content, _))] = client.calls[0][2]["files"]

simudyne_pulse-0.7.0.dev9/tests/test_run_lrm.py

@@ -0,0 +1,117 @@
+"""Tests for SimulationResource.run_lrm.
+
+The HTTP layer is stubbed, so these check the payload the SDK builds and the
+endpoint it targets, not a live service.
+"""
+
+import pytest
+
+from simudyne.resources.simulation import LRM_RUN_PATH, SimulationResource
+
+
+class _StubClient:
+    """Captures the request the resource makes."""
+
+    def __init__(self):
+        self.calls = []
+
+    def _request(self, method, endpoint, **kwargs):
+        self.calls.append((method, endpoint, kwargs))
+        return {"job_id": "job-abc", "total_jobs": 250}
+
+    @property
+    def last(self):
+        return self.calls[-1]
+
+
+@pytest.fixture
+def resource():
+    client = _StubClient()
+    res = SimulationResource(client)
+    res._stub = client
+    return res
+
+
+def _run(resource, **kw):
+    base = dict(
+        symbol="700.HK",
+        cal_date="2025-09-02",
+        provider="omd",
+        exchange="hkex_securities",
+        order_sizes=[500, 1000, 2000, 4000],
+    )
+    base.update(kw)
+    return resource.run_lrm(**base)
+
+
+class TestEndpoint:
+
+    def test_posts_to_the_lrm_path(self, resource):
+        _run(resource)
+        method, endpoint, _ = resource._stub.last
+        assert method == "POST"
+        assert endpoint == LRM_RUN_PATH == "/simulation/lrm/run"
+
+    def test_returns_the_server_response(self, resource):
+        assert _run(resource)["job_id"] == "job-abc"
+
+
+class TestPayload:
+
+    def test_carries_the_symbol_identity_and_ladder(self, resource):
+        _run(resource)
+        payload = resource._stub.last[2]["json"]
+        assert payload["symbol"] == "700.HK"
+        assert payload["cal_date"] == "2025-09-02"
+        assert payload["provider"] == "omd"
+        assert payload["exchange"] == "hkex_securities"
+        assert payload["order_sizes"] == [500, 1000, 2000, 4000]
+
+    def test_defaults(self, resource):
+        _run(resource)
+        payload = resource._stub.last[2]["json"]
+        assert payload["n_runs"] == 50
+        assert payload["seed"] == 42
+        assert payload["horizon_mins"] == 60
+        assert payload["strategy"] == "vwap"
+        assert payload["scenario"] == "normal"
+
+    def test_unset_optionals_are_omitted(self, resource):
+        # A null side would override the server default instead of letting the
+        # sign of each order size pick the direction.
+        _run(resource)
+        payload = resource._stub.last[2]["json"]
+        assert "side" not in payload
+        assert "start_time" not in payload
+        assert "scenario_params" not in payload
+
+    def test_optionals_are_sent_when_given(self, resource):
+        _run(resource, side="sell", start_time="09:30",
+             scenario="flash_crash", scenario_params={"start_time": "10:00"})
+        payload = resource._stub.last[2]["json"]
+        assert payload["side"] == "sell"
+        assert payload["start_time"] == "09:30"
+        assert payload["scenario"] == "flash_crash"
+        assert payload["scenario_params"] == {"start_time": "10:00"}
+
+    def test_order_sizes_are_copied_not_aliased(self, resource):
+        sizes = [500, 1000]
+        _run(resource, order_sizes=sizes)
+        sizes.append(9999)
+        assert resource._stub.last[2]["json"]["order_sizes"] == [500, 1000]
+
+    def test_negative_sizes_pass_through_for_buys(self, resource):
+        _run(resource, order_sizes=[-500, -1000])
+        assert resource._stub.last[2]["json"]["order_sizes"] == [-500, -1000]
+
+
+class TestSharedBaselineCost:
+
+    @pytest.mark.parametrize("n_sizes,n_runs,expected", [(4, 50, 250), (8, 50, 450), (8, 25, 225)])
+    def test_documented_job_count_matches_the_shared_baseline_shape(
+        self, resource, n_sizes, n_runs, expected
+    ):
+        # n_runs * (1 + n_sizes), the figure the docstring quotes.
+        _run(resource, order_sizes=list(range(100, 100 * (n_sizes + 1), 100)), n_runs=n_runs)
+        payload = resource._stub.last[2]["json"]
+        assert payload["n_runs"] * (1 + len(payload["order_sizes"])) == expected

{simudyne_pulse-0.7.0.dev7 → simudyne_pulse-0.7.0.dev9}/tests/test_validation.py

@@ -216,15 +216,70 @@ class TestSimulatedFrameShapes:
         return client.calls[0][2]["files"]
 
     def test_pair(self):
-        assert self._files_sent([("a.parquet", b"x")])[0][1] == ("a.parquet", b"x")
+        part = self._files_sent([("a.parquet", b"x")])[0][1]
+        assert part == ("a.parquet", b"x", "application/octet-stream")
 
     def test_path(self, tmp_path):
         p = tmp_path / "sim.parquet"
         p.write_bytes(b"data")
-        assert self._files_sent([str(p)])[0][1] == ("sim.parquet", b"data")
+        part = self._files_sent([str(p)])[0][1]
+        assert part == ("sim.parquet", b"data", "application/octet-stream")
 
     def test_each_frame_gets_its_own_name(self):
         pd = pytest.importorskip("pandas")
         frames = [pd.DataFrame({"a": [1]}), pd.DataFrame({"a": [2]})]
         names = [f[1][0] for f in self._files_sent(frames)]
         assert names == ["sim_0.parquet", "sim_1.parquet"]
+
+
+class TestNamedPopulations:
+    """Runs can be named so the results compare populations, not an average."""
+
+    def test_grouped_sim_ids_go_as_a_mapping(self):
+        client = FakeClient([{"job_id": "v1"}])
+        ValidationResource(client).run(
+            sim_ids={"fm": ["a"], "abm": ["b", "c"]}, **IDENTITY
+        )
+        assert client.calls[0][2]["json"]["sim_ids"] == {
+            "fm": ["a"],
+            "abm": ["b", "c"],
+        }
+
+    def test_the_total_is_what_is_capped(self):
+        client = FakeClient()
+        with pytest.raises(ValueError, match="Maximum 25"):
+            ValidationResource(client).run(
+                sim_ids={"a": ["x"] * 13, "b": ["y"] * 13}, **IDENTITY
+            )
+        assert client.calls == []
+
+    def test_grouped_uploads_travel_flat_with_the_grouping_beside_them(self):
+        """Multipart has no nesting, so the groups go in the config."""
+        client = FakeClient([{"job_id": "v1"}])
+        ValidationResource(client).run(
+            sim_files={"fm": [("a.parquet", b"x")],
+                       "abm": [("b.parquet", b"y"), ("c.parquet", b"z")]},
+            **IDENTITY,
+        )
+        kwargs = client.calls[0][2]
+        assert len(kwargs["files"]) == 3
+        assert json.loads(kwargs["data"]["config"])["sim_groups"] == {
+            "fm": [0], "abm": [1, 2]
+        }
+
+    def test_an_ungrouped_upload_carries_no_grouping(self):
+        client = FakeClient([{"job_id": "v1"}])
+        ValidationResource(client).run(
+            sim_files=[("a.parquet", b"x")], **IDENTITY
+        )
+        assert "sim_groups" not in json.loads(client.calls[0][2]["data"]["config"])
+
+
+class TestPlotAll:
+    def test_it_is_forwarded(self):
+        client, _ = _run([{"job_id": "v1"}], plot_all=True)
+        assert client.calls[0][2]["json"]["config"]["plot_all"] is True
+
+    def test_it_is_omitted_when_not_asked_for(self):
+        client, _ = _run([{"job_id": "v1"}])
+        assert "plot_all" not in client.calls[0][2]["json"]["config"]