simudyne-pulse 0.7.0.dev1__tar.gz → 0.7.0.dev2__tar.gz

{simudyne_pulse-0.7.0.dev1/src/simudyne_pulse.egg-info → simudyne_pulse-0.7.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simudyne-pulse
-Version: 0.7.0.dev1
+Version: 0.7.0.dev2
 Summary: Python SDK for the Simudyne Pulse synthetic market data API
 Author-email: Simudyne <support@simudyne.com>
 License-Expression: MIT

{simudyne_pulse-0.7.0.dev1 → simudyne_pulse-0.7.0.dev2}/pyproject.toml

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

{simudyne_pulse-0.7.0.dev1 → simudyne_pulse-0.7.0.dev2}/src/simudyne/client.py

@@ -36,6 +36,8 @@ class PulseABM:
         from simudyne.resources.profile import ProfileResource
         from simudyne.resources.api_keys import ApiKeysResource
         from simudyne.resources.data import DataResource
+        from simudyne.resources.fix import FixResource
+        from simudyne.resources.fm import FmResource
         from simudyne.resources.simulation import SimulationResource
         from simudyne.resources.simulator_gym import SimulatorGymResource
         from simudyne.resources.validation import ValidationResource
@@ -43,6 +45,8 @@ class PulseABM:
         self.profile = ProfileResource(self)
         self.api_keys = ApiKeysResource(self)
         self.data = DataResource(self)
+        self.fix = FixResource(self)
+        self.fm = FmResource(self)
         self.simulation = SimulationResource(self)
         self.simulator_gym = SimulatorGymResource(self)
         self.validation = ValidationResource(self)

simudyne_pulse-0.7.0.dev2/src/simudyne/resources/fix.py

@@ -0,0 +1,30 @@
+"""
+FIX Resource for the Pulse SDK.
+
+Pulse simulations can be consumed over the FIX protocol by a market-data
+session instead of the REST download endpoints. The FIX connection itself is
+provisioned per organisation (see the FIX docs page); this resource covers
+what the SDK can usefully do about it — reporting what your account has run
+over FIX.
+"""
+
+USAGE_PATH = "/fix/usage"
+
+
+class FixResource:
+    def __init__(self, client):
+        self._client = client
+
+    def usage(self) -> dict:
+        """FIX simulation statistics: what was run over FIX, and how often.
+
+        Returns:
+            dict with ``total_runs``, ``simulated_seconds``, and ``runs`` — one
+            entry per distinct configuration, each with its ``symbol``,
+            ``cal_date``, ``scenario`` and ``runs`` count.
+
+        Example:
+            >>> usage = client.fix.usage()
+            >>> print(f"{usage['total_runs']} FIX runs")
+        """
+        return self._client._request("GET", USAGE_PATH)

simudyne_pulse-0.7.0.dev2/src/simudyne/resources/fm.py

@@ -0,0 +1,199 @@
+"""
+Foundation Models Resource for the Pulse SDK.
+
+A foundation-model (FM) run generates limit order book activity by continuing
+from real market data rather than simulating agents. The platform slices the
+model's required context out of the chosen market's data, runs inference, and
+writes the output using the same conventions as an agent-based run — so the
+ordinary simulation results and download endpoints work unchanged.
+
+Workflow:
+    1. Discover models with models() — each entry lists the markets it
+       supports and the model_args it accepts
+    2. Find a promptable symbol/date with available_data(model_id=...)
+    3. Submit inference with run() -> returns job_id and sim_ids
+    4. Poll job_status(job_id) until it reaches a TERMINAL_STATUSES value;
+       read job_logs(job_id) when it failed
+    5. Download with client.simulation.get_sim_data(sim_id) — an FM sim_id is
+       an ordinary sim_id
+
+The output file contains the model's prompt context as well as its generated
+frames: the leading rows of sim_data.parquet are real market data. The split
+is recorded in the parquet file-level metadata (``pulse_fm.n_historical``,
+``pulse_fm.n_generated``, ``pulse_fm.segments``) — drop the context rows
+before computing statistics on the generated activity.
+"""
+
+MODELS_PATH = "/fm/models"
+AVAILABLE_DATA_PATH = "/fm/available-data"
+RUN_PATH = "/fm/run"
+LIVE_PATH = "/fm/live"
+JOBS_PATH = "/fm/jobs"
+
+#: The only statuses a job never leaves. Everything else (queued,
+#: provisioning, starting, running) means "keep polling".
+TERMINAL_STATUSES = {"complete", "failed"}
+
+
+class FmResource:
+    def __init__(self, client):
+        self._client = client
+
+    def models(self) -> dict:
+        """Active foundation models in this environment.
+
+        The pre-run discovery call: each entry carries the model's id and
+        version, the markets its ``supported_data`` declares (empty = any),
+        ``min_prompt_rows``, and the ``model_args`` descriptors for the knobs
+        run() will accept. Pro tier.
+
+        Returns:
+            dict with a ``models`` list.
+        """
+        return self._client._request("GET", MODELS_PATH)
+
+    def available_data(
+        self,
+        model_id: str = None,
+        symbol: str = None,
+        q: str = None,
+        provider: str = None,
+        exchange: str = None,
+        date: str = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> dict:
+        """What a foundation model can be prompted with: the raw-data registry.
+
+        An FM prompt is the first rows of a REAL trading day, not a
+        calibration, so this searches the raw-data catalog rather than the
+        calibrated list at data.get_available_symbols(). Passing ``model_id``
+        restricts the result to the (provider, exchange) markets that model's
+        ``supported_data`` declares — exactly what run() will accept.
+
+        Args:
+            model_id: Registered model (see models()). Unknown id -> 404.
+            symbol: Exact symbol, e.g. "TSCO" or "700".
+            q: Case-insensitive substring match over the symbol.
+            provider: Data provider, e.g. "bmll".
+            exchange: Protocol, e.g. "lse" or "hkex_securities".
+            date: Trading date YYYY-MM-DD; keeps only symbols with data on it,
+                and only that date.
+            limit: Max symbols to return (default 50, max 200).
+            offset: Symbols to skip, for paging.
+
+        Returns:
+            dict with ``symbols`` (each with its provider, exchange and dates)
+            and ``total``, paged by symbol identity.
+        """
+        params = {"limit": limit, "offset": offset}
+        for key, value in (
+            ("model_id", model_id), ("symbol", symbol), ("q", q),
+            ("provider", provider), ("exchange", exchange), ("date", date),
+        ):
+            if value is not None:
+                params[key] = value
+        return self._client._request("GET", AVAILABLE_DATA_PATH, params=params)
+
+    def run(
+        self,
+        model_id: str,
+        symbol: str,
+        cal_date: str,
+        provider: str,
+        exchange: str,
+        duration_minutes: float = None,
+        horizon: int = None,
+        n_runs: int = 1,
+        seed: int = 42,
+        model_args: dict = None,
+        device: str = None,
+        exec_algos: list = None,
+    ) -> dict:
+        """Submit a foundation-model inference job. Pro tier.
+
+        Args:
+            model_id: A model from models().
+            symbol: Symbol whose real data becomes the prompt context.
+            cal_date: Trading date of the prompt, YYYY-MM-DD.
+            provider: Data provider, e.g. "bmll".
+            exchange: Exchange protocol, e.g. "hkex_securities".
+            duration_minutes: Sim horizon as wall-clock minutes measured from
+                the first row of the context. The resulting frame count is
+                reported in the run's output rather than requested up front.
+            horizon: Raw frame count — the older form; applies only when
+                duration_minutes is unset.
+            n_runs: Monte Carlo runs, 1-8 (per-run seeds derived from ``seed``
+                exactly as the ABM derives them).
+            seed: Random seed (default 42).
+            model_args: Overrides for the model's declared knobs (see
+                models()); unknown or out-of-range keys are rejected with 400.
+            device: "cpu" or "gpu"; None uses the model's default.
+            exec_algos: Execution algorithms, the ABM's config shape. At most
+                one per job; market runs only.
+
+        Returns:
+            dict with job_id, the model version, and the queued sim_ids.
+        """
+        payload = {
+            "model_id": model_id,
+            "symbol": symbol,
+            "cal_date": cal_date,
+            "provider": provider,
+            "exchange": exchange,
+            "n_runs": n_runs,
+            "seed": seed,
+        }
+        if duration_minutes is not None:
+            payload["duration_minutes"] = duration_minutes
+        if horizon is not None:
+            payload["horizon"] = horizon
+        if model_args is not None:
+            payload["model_args"] = model_args
+        if device is not None:
+            payload["device"] = device
+        if exec_algos is not None:
+            payload["exec_algos"] = exec_algos
+        return self._client._request("POST", RUN_PATH, json=payload)
+
+    def live(
+        self,
+        model_id: str,
+        horizon: int = None,
+        seed: int = 42,
+        model_args: dict = None,
+    ) -> dict:
+        """Start a live streaming session instead of a batch job. Pro tier.
+
+        Returns:
+            dict with ``token`` (used to connect to the live chart),
+            ``job_id`` and ``model_id``.
+        """
+        payload = {"model_id": model_id, "seed": seed}
+        if horizon is not None:
+            payload["horizon"] = horizon
+        if model_args is not None:
+            payload["model_args"] = model_args
+        return self._client._request("POST", LIVE_PATH, json=payload)
+
+    def job_status(self, job_id: str) -> dict:
+        """Foundation-model job status.
+
+        Returns:
+            dict with job_id, ``status``, ``message``, ``detail``,
+            ``started_at`` and ``completed_at``. ``status`` is one of queued,
+            provisioning, starting, running, complete or failed — only the
+            last two are terminal (see TERMINAL_STATUSES), so poll until one
+            of those appears. ``message`` is the human label for the state and
+            ``detail`` says what the run is waiting on (a GPU stockout reads
+            as the scheduler's own reason).
+        """
+        return self._client._request("GET", f"{JOBS_PATH}/{job_id}/status")
+
+    def job_logs(self, job_id: str) -> dict:
+        """Foundation-model job pod logs.
+
+        Returns:
+            dict with ``logs`` — the thing to read when a job failed.
+        """
+        return self._client._request("GET", f"{JOBS_PATH}/{job_id}/logs")

{simudyne_pulse-0.7.0.dev1 → simudyne_pulse-0.7.0.dev2}/src/simudyne/resources/simulation.py

@@ -21,6 +21,7 @@ RESULTS_PATH = "/simulation/results"
 CACHED_PATH = "/simulation/cached"
 SAMPLE_PATH = "/simulation/sample"
 CALIBRATE_PATH = "/calibrate"
+LRM_PATH = "/simulation/lrm/run"
 
 # Available market scenarios
 SCENARIOS = {
@@ -437,6 +438,83 @@ class SimulationResource:
         """
         return self._pro_request("GET", f"{JOBS_PATH}/{job_id}/results")
 
+    def get_job_logs(self, job_id: str) -> str:
+        """Fetch the engine run log for one of your jobs, as plain text.
+
+        The worker writes a diagnostic log per job — this is the thing to read
+        when a run fails or finishes with nothing plottable, and the thing to
+        attach when sending a problem to support@simudyne.com.
+
+        Args:
+            job_id: The job ID from run() or get_jobs()
+
+        Returns:
+            str: The log text.
+
+        Raises:
+            PulseAPIError: 404 when the job does not exist, is not yours, or
+                wrote no log.
+
+        Example:
+            >>> status = client.simulation.get_job_status(job_id)
+            >>> if status["has_errors"]:
+            ...     print(client.simulation.get_job_logs(job_id)[:2000])
+        """
+        # Plain text, not JSON — go through the retrying transport directly.
+        url = f"{self._client.base_url}{JOBS_PATH}/{job_id}/logs"
+        response = self._client._request_with_retries("GET", url)
+        return response.text
+
+    def run_lrm(
+        self,
+        symbol: str,
+        cal_date: str,
+        provider: str,
+        exchange: str,
+        order_sizes: list,
+        n_runs: int = 50,
+        seed: int = 42,
+        horizon_mins: int = 60,
+        strategy: str = "vwap",
+        side: str = None,
+    ):
+        """Run a liquidity-risk grid: market impact across a ladder of order sizes.
+
+        One execution algo is built per entry in order_sizes, and all of them
+        share a single baseline, so the cost is ``n_runs * (1 + len(order_sizes))``
+        simulations rather than one baseline per size. Poll the returned job_id
+        through the usual job endpoints.
+
+        Args:
+            symbol: Trading symbol (e.g. "700")
+            cal_date: Calibration date in YYYY-MM-DD format
+            provider: Data provider (e.g. "omd", "bmll")
+            exchange: Exchange protocol (e.g. "hkex_securities")
+            order_sizes: Order sizes in LOTS — one algo per entry
+            n_runs: Monte Carlo runs per arm (default 50)
+            seed: Random seed (default 42)
+            horizon_mins: Execution horizon in minutes (default 60)
+            strategy: "vwap" or "twap" (default "vwap")
+            side: "buy" or "sell"; defaults to the sign of each order size
+
+        Returns:
+            dict with job_id and the queued sim_ids
+        """
+        payload = {
+            "symbol": symbol,
+            "cal_date": cal_date,
+            "provider": provider,
+            "exchange": exchange,
+            "order_sizes": order_sizes,
+            "n_runs": n_runs,
+            "seed": seed,
+            "horizon_mins": horizon_mins,
+            "strategy": strategy,
+        }
+        if side is not None:
+            payload["side"] = side
+        return self._pro_request("POST", LRM_PATH, json=payload)
+
     def list_sim_files(self, sim_id: str):
         """
         List available files for a specific simulation.

{simudyne_pulse-0.7.0.dev1 → simudyne_pulse-0.7.0.dev2}/src/simudyne/resources/validation.py

@@ -27,18 +27,24 @@ pass, or ``True`` to force one on.
 ``run_inception_distances`` is the exception: it defaults to ``True``, so MIND
 and FID are computed unless you opt out. It maps to the API's ``run_fid``
 config field, which gates both metrics because they share one DeepLOB
-embedding pass. Note the scores are returned to the demo tier only — on any
-other tier a ``True`` here spends the embedding pass and the response withholds
-the numbers, so pass ``False`` if that is your situation.
+embedding pass. As of pulse-api-pod 1.56.0 the scores are returned to every
+validation tier; on older API deployments they reach the demo tier only.
 """
 
 import base64
+import json
 import time
+from pathlib import Path
 
 
 RUN_PATH = "/validation/run"
+UPLOAD_PATH = "/validation/run/upload"
 JOBS_PATH = "/validation/jobs"
 
+#: The API rejects more per job; checked client-side so a 26-file submission
+#: fails before any bytes are uploaded.
+MAX_SIM_FILES = 25
+
 #: Flags the API resolves from the caller's tier when left unset.
 _TRI_STATE_FLAGS = (
     "run_metrics",
@@ -52,6 +58,35 @@ _TRI_STATE_FLAGS = (
 _INCEPTION_WIRE_FIELD = "run_fid"
 
 
+def _build_config(
+    run_metrics,
+    run_impact,
+    run_inception_distances,
+    run_stylised_facts,
+    plot_data,
+    n_levels,
+    l2_only,
+) -> dict:
+    """The validation config object as the API expects it.
+
+    Tri-state flags left as None are omitted rather than sent as null: the API
+    reads absence as "use my tier's default", and an explicit null would not
+    do that.
+    """
+    config = {
+        "n_levels": n_levels,
+        "l2_only": l2_only,
+        _INCEPTION_WIRE_FIELD: run_inception_distances,
+    }
+    for flag, value in zip(
+        _TRI_STATE_FLAGS,
+        (run_metrics, run_impact, run_stylised_facts, plot_data),
+    ):
+        if value is not None:
+            config[flag] = value
+    return config
+
+
 class ValidationResource:
     def __init__(self, client):
         self._client = client
@@ -88,13 +123,16 @@ class ValidationResource:
             ticksize: Tick size for the symbol
             run_metrics: Compute L1/Wasserstein distributional distances
                 (None = tier default)
-            run_impact: Compute impact response curves (None = tier default).
-                Only computed when plot_data is on — it has no verdict-only form.
+            run_impact: Compute Bouchaud impact response curves for each
+                simulated run (None = tier default). Runs on every tier as of
+                pulse 2.17.0 / pulse-api-pod 1.62.0; the historical curve is
+                additionally included on demo (plot_data) jobs. Older API
+                deployments only compute it when plot_data is on.
             run_inception_distances: Compute MIND *and* FID on DeepLOB
                 embeddings (default True). One flag gates both — they share a
                 single embedding pass. Sent as the API's ``run_fid`` field.
-                The scores reach the demo tier only, so on another tier this
-                spends the pass and the response withholds the numbers.
+                Scores are returned to every validation tier (API >= 1.56.0;
+                demo-only before that).
             run_stylised_facts: Compute the 11 Cont stylised facts
                 (None = tier default)
             plot_data: Store the raw data behind every plot — distribution
@@ -114,19 +152,10 @@ class ValidationResource:
         Returns:
             dict with job_id, status, message
         """
-        config = {
-            "n_levels": n_levels,
-            "l2_only": l2_only,
-            _INCEPTION_WIRE_FIELD: run_inception_distances,
-        }
-        for flag, value in zip(
-            _TRI_STATE_FLAGS,
-            (run_metrics, run_impact, run_stylised_facts, plot_data),
-        ):
-            # Omitted rather than sent as None: the API reads absence as "use my
-            # tier's default", and sending an explicit null would not do that.
-            if value is not None:
-                config[flag] = value
+        config = _build_config(
+            run_metrics, run_impact, run_inception_distances,
+            run_stylised_facts, plot_data, n_levels, l2_only,
+        )
 
         payload = {
             "symbol": symbol,
@@ -142,6 +171,85 @@ class ValidationResource:
 
         return self._client._request("POST", RUN_PATH, json=payload)
 
+    def run_upload(
+        self,
+        symbol: str,
+        date: str,
+        provider: str,
+        exchange: str,
+        sim_files: list,
+        ticksize: float = 1.0,
+        run_metrics: bool = None,
+        run_impact: bool = None,
+        run_inception_distances: bool = True,
+        run_stylised_facts: bool = None,
+        plot_data: bool = None,
+        n_levels: int = 10,
+        l2_only: bool = False,
+    ) -> dict:
+        """Submit a validation job from simulation files you hold yourself.
+
+        Same scoring as run(), for output that is not stored in Pulse —
+        parquets from your own systems, a local engine build, or a different
+        generator entirely. The historical side is still fetched server-side,
+        so only the simulated frames are uploaded.
+
+        Args:
+            symbol: Trading symbol (e.g. "700.HK")
+            date: Calibration date in YYYY-MM-DD format
+            provider: Data provider (e.g. "omd"). Required — with no sim_ids
+                to parse it from, it is the only way to identify the
+                historical day.
+            exchange: Exchange protocol (e.g. "hkex_securities"). Required,
+                same reason.
+            sim_files: 1-25 simulated frames, each either a path to a parquet
+                file or a ``(filename, bytes)`` pair for frames already in
+                memory.
+            ticksize: Tick size for the symbol.
+
+        The run flags mean exactly what they mean on run().
+
+        Returns:
+            dict with job_id, status, message
+
+        Raises:
+            ValueError: before any request, if sim_files is empty or has more
+                than 25 entries.
+        """
+        if not sim_files:
+            raise ValueError("sim_files is empty — supply 1 to 25 files")
+        if len(sim_files) > MAX_SIM_FILES:
+            raise ValueError(
+                f"{len(sim_files)} sim_files — the API accepts at most "
+                f"{MAX_SIM_FILES} per validation job"
+            )
+
+        config = _build_config(
+            run_metrics, run_impact, run_inception_distances,
+            run_stylised_facts, plot_data, n_levels, l2_only,
+        )
+
+        files = []
+        for entry in sim_files:
+            if isinstance(entry, tuple):
+                filename, content = entry
+            else:
+                path = Path(entry)
+                filename, content = path.name, path.read_bytes()
+            files.append(
+                ("sim_files", (filename, content, "application/octet-stream"))
+            )
+
+        data = {
+            "symbol": symbol,
+            "date": date,
+            "provider": provider,
+            "exchange": exchange,
+            "ticksize": str(ticksize),
+            "config": json.dumps(config),
+        }
+        return self._client._request("POST", UPLOAD_PATH, files=files, data=data)
+
     def get_job(self, job_id: str) -> dict:
         """Get validation job status and results.
 
@@ -155,13 +263,21 @@ class ValidationResource:
             - stylised_fact_verdicts: {fact: {historical: bool | None,
               simulated: [bool | None, ...]}} — every entitled tier
             - mind_scores: one Monge Inception Distance per sim run, in sim_ids
-              order; None where a run could not be embedded. Demo tier only
+              order; None where a run could not be embedded. Every validation
+              tier (API >= 1.56.0)
             - fid_scores: one Frechet Inception Distance per sim run, same
               ordering and tier rule. Since pulse-check 1.8.0 this is the
               embedding-space FID — not comparable with values stored by older
               jobs
-            - distributions / impact_response / stylised_facts: the full
-              historical-derived payloads. Demo tier, plot_data jobs only
+            - impact_response: Bouchaud response curves — lags and events are
+              the axes, and simulated holds one {ys, ci_low, ci_high} block
+              per run, indexed [event][lag]. Every tier (pulse-api-pod >=
+              1.62.0); the historical block appears on demo plot_data jobs only
+            - impact_response_error: set when the impact pass was requested
+              but failed, so a null impact_response can be told apart from one
+              never asked for
+            - distributions / stylised_facts: the full historical-derived
+              payloads. Demo tier, plot_data jobs only
             - plots: {distributions: [...], distances: [...],
               impact_response: [...]} of {name, content_base64}
             - metadata: dict with run parameters
@@ -314,8 +430,9 @@ class ValidationResource:
         Raises:
             RuntimeError: If the job fails, or if the scores come back empty —
                 which means the pipeline skipped them (missing torch, fewer
-                than 10 levels, unreachable checkpoint) or the key is not on
-                the demo tier, both of which are silent in the raw response.
+                than 10 levels, unreachable checkpoint), or the API predates
+                1.56.0 and the key is not demo tier; both are silent in the
+                raw response.
 
         Interpreting the scores:
             Lower = closer to the historical day, but neither number means
@@ -346,8 +463,8 @@ class ValidationResource:
             raise RuntimeError(
                 "no inception distances in the response. Either the pipeline "
                 "skipped them (torch missing, fewer than 10 book levels, or "
-                "the DeepLOB checkpoint unreachable) or this API key is not on "
-                "the demo tier, which is the only tier they are shared with."
+                "the DeepLOB checkpoint unreachable), or the API predates "
+                "1.56.0 and this key is not demo tier."
             )
 
         return {

{simudyne_pulse-0.7.0.dev1 → simudyne_pulse-0.7.0.dev2/src/simudyne_pulse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simudyne-pulse
-Version: 0.7.0.dev1
+Version: 0.7.0.dev2
 Summary: Python SDK for the Simudyne Pulse synthetic market data API
 Author-email: Simudyne <support@simudyne.com>
 License-Expression: MIT

{simudyne_pulse-0.7.0.dev1 → simudyne_pulse-0.7.0.dev2}/src/simudyne_pulse.egg-info/SOURCES.txt

@@ -7,6 +7,8 @@ src/simudyne/exceptions.py
 src/simudyne/resources/__init__.py
 src/simudyne/resources/api_keys.py
 src/simudyne/resources/data.py
+src/simudyne/resources/fix.py
+src/simudyne/resources/fm.py
 src/simudyne/resources/historical.py
 src/simudyne/resources/profile.py
 src/simudyne/resources/simulation.py
@@ -17,5 +19,6 @@ 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_new_resources.py
 tests/test_simulator_gym.py
 tests/test_validation.py

simudyne_pulse-0.7.0.dev2/tests/test_new_resources.py

@@ -0,0 +1,150 @@
+"""Payload tests for the 0.8.0 surface: validation.run_upload, 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
+contract the docs describe: field names, which flags are omitted when unset,
+and the client-side sim_files limit that must fail before any bytes move.
+"""
+
+import json
+
+import pytest
+
+from simudyne.resources.fix import FixResource
+from simudyne.resources.fm import FmResource, TERMINAL_STATUSES
+from simudyne.resources.simulation import SimulationResource
+from simudyne.resources.validation import ValidationResource
+
+
+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 {}
+
+
+class TestRunUpload:
+    def test_rejects_empty_before_any_request(self):
+        client = FakeClient()
+        with pytest.raises(ValueError, match="empty"):
+            ValidationResource(client).run_upload(
+                "700.HK", "2025-09-01", "omd", "hkex_securities", sim_files=[]
+            )
+        assert client.calls == []
+
+    def test_rejects_more_than_25_before_any_request(self):
+        client = FakeClient()
+        files = [(f"sim_{i}.parquet", b"x") for i in range(26)]
+        with pytest.raises(ValueError, match="25"):
+            ValidationResource(client).run_upload(
+                "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(
+            "700.HK", "2025-09-01", "omd", "hkex_securities",
+            sim_files=[("sim_0000.parquet", b"PARQ")],
+            ticksize=0.5,
+            run_metrics=False,
+        )
+        method, path, kwargs = client.calls[0]
+        assert (method, path) == ("POST", "/validation/run/upload")
+        data = kwargs["data"]
+        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"):
+            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"
+
+    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(
+            "700.HK", "2025-09-01", "omd", "hkex_securities", sim_files=[p]
+        )
+        [(_, (filename, content, _))] = client.calls[0][2]["files"]
+        assert filename == "sim_0001.parquet" and content == b"BYTES"
+
+
+class TestFmResource:
+    def test_terminal_statuses_are_the_two_documented(self):
+        assert TERMINAL_STATUSES == {"complete", "failed"}
+
+    def test_models_and_status_paths(self):
+        client = FakeClient([{}, {}])
+        fm = FmResource(client)
+        fm.models()
+        fm.job_status("j1")
+        assert client.calls[0][:2] == ("GET", "/fm/models")
+        assert client.calls[1][:2] == ("GET", "/fm/jobs/j1/status")
+
+    def test_available_data_omits_unset_filters(self):
+        client = FakeClient([{}])
+        FmResource(client).available_data(model_id="tradefm-hkex", limit=5)
+        _, path, kwargs = client.calls[0]
+        assert path == "/fm/available-data"
+        assert kwargs["params"] == {"model_id": "tradefm-hkex", "limit": 5, "offset": 0}
+
+    def test_run_sends_only_what_is_set(self):
+        client = FakeClient([{}])
+        FmResource(client).run(
+            "tradefm-hkex", "700", "2025-09-02", "bmll", "hkex_securities",
+            duration_minutes=30, n_runs=4, model_args={"temperature": 0.8},
+        )
+        _, path, kwargs = client.calls[0]
+        body = kwargs["json"]
+        assert path == "/fm/run"
+        assert body["duration_minutes"] == 30 and body["n_runs"] == 4
+        assert body["model_args"] == {"temperature": 0.8}
+        for absent in ("horizon", "device", "exec_algos"):
+            assert absent not in body
+
+
+class TestFixResource:
+    def test_usage_path(self):
+        client = FakeClient([{}])
+        FixResource(client).usage()
+        assert client.calls[0][:2] == ("GET", "/fix/usage")
+
+
+class TestSimulationAdditions:
+    def test_run_lrm_payload(self):
+        client = FakeClient([{}])
+        SimulationResource(client).run_lrm(
+            "700", "2025-09-02", "omd", "hkex_securities",
+            order_sizes=[10, 50, 100], side="buy",
+        )
+        method, path, kwargs = client.calls[0]
+        assert (method, path) == ("POST", "/simulation/lrm/run")
+        body = kwargs["json"]
+        assert body["order_sizes"] == [10, 50, 100]
+        assert body["strategy"] == "vwap" and body["side"] == "buy"
+
+    def test_get_job_logs_returns_plain_text(self):
+        class TextClient(FakeClient):
+            base_url = "https://api.test"
+
+            def _request_with_retries(self, method, url, **kwargs):
+                self.calls.append((method, url, kwargs))
+
+                class R:
+                    text = "engine log line"
+
+                return R()
+
+        client = TextClient()
+        out = SimulationResource(client).get_job_logs("job-1")
+        assert out == "engine log line"
+        assert client.calls[0][1].endswith("/simulation/jobs/job-1/logs")