alphaengine 0.1.0__tar.gz → 0.1.2__tar.gz

alphaengine-0.1.2/CHANGELOG.md

@@ -0,0 +1,108 @@
+# Changelog
+
+Every entry that changes a computed value says so in the first line, because a
+saved study has to reproduce years after it was written. See `_version.py` for
+the versioning rule: while the leading digit is 0, a changed figure costs a
+minor bump.
+
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [0.1.2] - 2026-07-31
+
+**No computed value changed.** Identical figures to 0.1.0 and 0.1.1.
+
+### Fixed
+
+- `report()` used `try`/`except`/`pass` to read an error body, which ruff's
+  SIM105 correctly objects to. It is `contextlib.suppress` now. The intent was
+  always total suppression: a server answering with HTML, an empty body or
+  nothing at all still has to produce a usable error rather than a second
+  exception raised on top of the first.
+
+### Changed
+
+- `DEFAULT_BASE_URL` points at the live platform. 0.1.1 shipped with a
+  placeholder host, so every `report()` call that did not pass `base_url` or set
+  `QUANTOS_API_URL` resolved to a domain that does not answer. Reporting was
+  effectively unusable at its default in that release.
+
+## [0.1.1] - 2026-07-31
+
+**No computed value changed.** Every figure this version produces is identical
+to 0.1.0; the goldens are untouched. A study saved by 0.1.0 reproduces here.
+
+### Added
+
+- `report()`, which sends a study to a QuantOS workspace. The offline half is
+  unchanged and always will be: `save()` still needs no account, no key and no
+  network. What it could not do was reach the person who has to act on the
+  work, so a run done in a notebook stayed in the notebook. This is that
+  crossing, and nothing else about the package assumes you will ever call it.
+
+  Available as `alphaengine.report(study, ...)` and as `Study.report()`. A key
+  comes from `QUANTOS_API_KEY` unless passed explicitly, because a key pasted
+  into a notebook is a key committed to git. `QUANTOS_API_URL` points it at a
+  self-hosted or VPC deployment.
+
+- A client-side series guard on the reported payload, keyed on LENGTH rather
+  than field name, so renaming a key cannot smuggle a return series past it.
+  The same check runs on the server. The duplication is deliberate: a check
+  that runs only on the client is not a check, and one that runs only on the
+  server tells you too late and without naming the field.
+
+  What crosses is an explicit allowlist — the trial count and how it was
+  obtained, the data hash, the verdict, the surface, the performance figures. A
+  field added to `Study` later does not start leaving the machine because
+  somebody forgot to exclude it. `best_params` is absent on purpose: the grid
+  is frequently bigger intellectual property than the returns.
+
+### Unchanged, and enforced
+
+- `import alphaengine` still makes no network call and pulls in no HTTP client.
+  Reporting is the one thing here that touches a network, so it is the one
+  thing not imported until you ask for it — `report` resolves through a module
+  `__getattr__` rather than at import time. Two tests hold that line: one
+  asserts no HTTP client lands in `sys.modules`, the other that the top level
+  never drags in the client subpackage.
+
+- Still two runtime dependencies. Reporting uses `urllib` from the standard
+  library rather than `requests`, because a third dependency would be a cost
+  paid by every user of the offline half, who did not ask for it.
+
+## [0.1.0] - 2026-07-30
+
+First public release. No figures changed, because there is nothing yet to
+change them from.
+
+### Added
+
+- `sweep()`, which runs a parameter grid through the caller's own backtest
+  function and derives the trial count from the grid rather than accepting it as
+  an argument. The signature has no `n_trials` parameter and a test pins that
+  absence, since a supplied count makes the deflation self-reported.
+- `SweepResult.verdict()`, reporting the deflated Sharpe ratio, PSR, minimum
+  track record length and a performance summary. Probability of backtest
+  overfitting is reported beside them under `selection` and is deliberately not
+  the gate: measured on a null-versus-edge fixture it does not discriminate
+  where the deflated Sharpe does, so gating on it would reject real results.
+- `SweepResult.surface()`, classifying the parameter neighbourhood as a plateau,
+  a ridge or a knife edge, with the robust region per parameter when parameters
+  are being stored.
+- The `Study` artifact and its versioned JSON schema. `load()` refuses an
+  unknown major version rather than half-parsing it, and tolerates unknown
+  fields within a known major so a newer writer stays readable by an older
+  build. A study holds derived figures and hashes, never a series.
+- `alphaengine.core`: deflated Sharpe, PSR, PBO by CSCV, minimum track record
+  length, a performance report, value at risk and conditional value at risk,
+  factor decomposition, cointegration tests and a signal backtest. Each cites
+  its source in the docstring.
+
+### Notes on defaults
+
+- Parameter values are **not** stored unless `store_params=True`. A parameter
+  grid is frequently larger intellectual property than the return series it
+  produced. Hashes are always kept, so two runs stay comparable without the
+  values leaving the machine.
+- Data identity is a content hash of the series, never a caller-supplied label,
+  so renaming an experiment does not detach it from its history.
+- Importing the package makes no network call and requires no account.

{alphaengine-0.1.0 → alphaengine-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alphaengine
-Version: 0.1.0
+Version: 0.1.2
 Summary: Validated research tooling for investment strategies: deflation, overfitting detection, and honest trial counts.
 Project-URL: Homepage, https://github.com/quantOSC/alphaengine
 Project-URL: Documentation, https://github.com/quantOSC/alphaengine#readme
@@ -91,6 +91,33 @@ research environment. `import alphaengine` makes no network call and needs no
 account. Factor decomposition and cointegration testing need statsmodels and
 are available as `pip install 'alphaengine[factors]'`.
 
+## Getting a study to somebody else
+
+`save()` writes to your disk and needs no account. When the work has to reach
+the PM who will act on it, `report()` sends the study — and only the study.
+
+```python
+import os
+from alphaengine import Study, sweep
+
+os.environ["QUANTOS_API_KEY"] = "ae_live_..."   # created in the portal
+
+r = sweep(backtest_fn, grid, data=prices)
+r.save()                                        # yours, on your disk, always
+
+Study.from_sweep(r, label="momentum, 9 configs").report()
+```
+
+What crosses is an explicit allowlist: the trial count and how it was obtained,
+a content hash of the data, the verdict, the shape of the neighbourhood, the
+performance figures. Your returns, your prices and your parameter grid stay on
+the machine, and a guard keyed on length rather than field name refuses to send
+anything series-shaped whatever it is called.
+
+Reporting is the only part of this package that touches a network, so it is the
+only part that is not imported until you call it. `import alphaengine` still
+makes no network call.
+
 ## Where this sits in QuantOS
 
 AlphaEngine is the open research layer of the [QuantOS](https://github.com/quantOSC)

{alphaengine-0.1.0 → alphaengine-0.1.2}/README.md

@@ -50,6 +50,33 @@ research environment. `import alphaengine` makes no network call and needs no
 account. Factor decomposition and cointegration testing need statsmodels and
 are available as `pip install 'alphaengine[factors]'`.
 
+## Getting a study to somebody else
+
+`save()` writes to your disk and needs no account. When the work has to reach
+the PM who will act on it, `report()` sends the study — and only the study.
+
+```python
+import os
+from alphaengine import Study, sweep
+
+os.environ["QUANTOS_API_KEY"] = "ae_live_..."   # created in the portal
+
+r = sweep(backtest_fn, grid, data=prices)
+r.save()                                        # yours, on your disk, always
+
+Study.from_sweep(r, label="momentum, 9 configs").report()
+```
+
+What crosses is an explicit allowlist: the trial count and how it was obtained,
+a content hash of the data, the verdict, the shape of the neighbourhood, the
+performance figures. Your returns, your prices and your parameter grid stay on
+the machine, and a guard keyed on length rather than field name refuses to send
+anything series-shaped whatever it is called.
+
+Reporting is the only part of this package that touches a network, so it is the
+only part that is not imported until you call it. `import alphaengine` still
+makes no network call.
+
 ## Where this sits in QuantOS
 
 AlphaEngine is the open research layer of the [QuantOS](https://github.com/quantOSC)

{alphaengine-0.1.0 → alphaengine-0.1.2}/src/alphaengine/__init__.py

@@ -27,6 +27,8 @@ OFFLINE BY CONSTRUCTION
     and your data never leaves the machine.
 """
 
+from typing import Any
+
 from ._version import __version__
 from .study import SCHEMA_VERSION, Study, load, save
 from .sweep import SweepResult, sweep
@@ -43,5 +45,23 @@ __all__ = [
     "Study",
     "save",
     "load",
+    "report",
+    "ReportError",
     "SCHEMA_VERSION",
 ]
+
+
+def __getattr__(name: str) -> Any:  # PEP 562
+    """`report` and `ReportError` load on first use.
+
+    Everything else in this package is offline by construction and imports
+    eagerly. Reporting is the one thing that touches a network, so it is the one
+    thing that is not imported until you ask for it — which is what keeps
+    `import alphaengine` free of networking code entirely.
+    """
+    if name in ("report", "ReportError"):
+        import importlib
+
+        mod = importlib.import_module(".study.report", __name__)
+        return getattr(mod, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{alphaengine-0.1.0 → alphaengine-0.1.2}/src/alphaengine/_version.py

@@ -12,4 +12,4 @@ While the leading digit is 0, the MINOR position carries that rule: 0.1 -> 0.2
 is what a changed figure costs. The API may still move underneath it.
 """
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"

alphaengine-0.1.2/src/alphaengine/agent/__init__.py

@@ -0,0 +1,16 @@
+"""Drive a workflow run with a model you supply.
+
+    from alphaengine.agent import AgentDriver
+
+The agent's action space is the permitted set the server sent this turn, so it
+cannot call an unoffered operation, skip a gate, proceed past a stop, or act
+without a record. See `driver.py` for why each of those holds by construction.
+
+No model dependency, no key handling, no inference call. `choose` is yours.
+"""
+
+from __future__ import annotations
+
+from .driver import AgentDriver, Choice, RefusedChoice
+
+__all__ = ["AgentDriver", "Choice", "RefusedChoice"]

alphaengine-0.1.2/src/alphaengine/agent/driver.py

@@ -0,0 +1,117 @@
+"""The agent driver: a model chooses among the steps it was just offered.
+
+    from alphaengine.agent import AgentDriver
+
+    driver = AgentDriver(choose=my_model_fn)   # your key, your model, your call
+    driver.drive(run)
+
+WHAT BOUNDS THE AGENT, CONCRETELY
+    Its action space is the permitted set the server sent this turn. Not the
+    library's function list, not a tool catalogue, not anything it can name.
+
+    So it cannot call something that was not offered, cannot skip a gate (gates
+    are evaluated server side on the result), cannot proceed past a stop (no
+    next step is issued), and cannot act without a record (the only thing it can
+    do is execute steps, and every step writes).
+
+    That is true by construction rather than by policy, which is the sentence
+    worth putting in front of a compliance reviewer. This module is deliberately
+    small: the guarantee comes from what it CANNOT reach, so the code that could
+    weaken it is code that is not here.
+
+YOUR MODEL, YOUR KEY, YOUR MACHINE
+    `choose` is a callable you supply. This package has no model dependency, no
+    API key handling, and makes no inference call. It never sees your
+    credentials because it never has a reason to.
+
+THE ONE THING THE AGENT ACTUALLY DECIDES
+    On a selection="all" turn, nothing: the steps do not branch and all of them
+    run. On selection="any", it picks one. That is the real decision point, and
+    keeping it that narrow is what makes an agent-driven run as auditable as a
+    hand-driven one.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["AgentDriver", "Choice", "RefusedChoice"]
+
+# Your model, given the permitted steps and what the run has produced so far,
+# returns the index of the step to take. Nothing else: not a step it invented,
+# not a parameter override, not an instruction.
+Choice = Callable[[list[dict[str, Any]], dict[str, Any]], int]
+
+
+class RefusedChoice(RuntimeError):
+    """The chooser returned something outside the permitted set.
+
+    Raised rather than clamped. Silently coercing an out-of-range choice to a
+    valid one would mean the run continues while the record says the agent chose
+    something it did not, and a trace that misreports the decision is worse than
+    a run that stops.
+    """
+
+
+@dataclass
+class AgentDriver:
+    """Drives a run by asking `choose` which permitted step to take."""
+
+    choose: Choice
+    max_steps: int = 200
+
+    def drive(self, run: Any) -> Any:
+        """Run until it stops or closes.
+
+        A stop returns normally. The agent is not given the chance to react to
+        one, because there is nothing to react to: no next step is issued, and
+        an agent that could argue with a gate would not be bounded by it.
+        """
+        n = 0
+        while run.status == "open":
+            if n >= self.max_steps:
+                raise RuntimeError(f"run {run.run_id} exceeded {self.max_steps} steps")
+
+            if not run.permitted:
+                run.resume()
+                if run.status != "open" or not run.permitted:
+                    break
+
+            if run.selection == "all":
+                # No decision to make: these do not branch, so all of them run.
+                # The agent is not consulted, which is correct rather than a
+                # shortcut. Asking it to "choose" among steps that all execute
+                # would invent a decision and then record it as one.
+                for step in list(run.permitted):
+                    run.step(step)
+                    n += 1
+                    if run.status != "open":
+                        return run
+                continue
+
+            index = self._ask(run)
+            run.step(run.permitted[index])
+            n += 1
+        return run
+
+    def _ask(self, run: Any) -> int:
+        permitted = list(run.permitted)
+        # The chooser sees the steps and the run's own figures. It does not see
+        # the workflow, because neither does this process.
+        try:
+            index = int(self.choose(permitted, dict(getattr(run, "figures", {}) or {})))
+        except (TypeError, ValueError) as exc:
+            raise RefusedChoice(f"chooser did not return a step index: {exc}") from exc
+
+        if not 0 <= index < len(permitted):
+            raise RefusedChoice(
+                f"chooser returned index {index}, outside the {len(permitted)} "
+                "steps that were permitted. It may only pick from what was offered."
+            )
+        logger.info("agent chose %s", permitted[index]["op"])
+        return index

alphaengine-0.1.2/src/alphaengine/client/__init__.py

@@ -0,0 +1,38 @@
+"""Client for a workflow server: execute steps locally, report figures.
+
+    from alphaengine.client import connect
+
+    session = connect("https://...", api_key="...")
+    run = session.open("validate_study", data=prices, backtest_fn=mine, grid={...})
+    run.drive()
+
+THE SPLIT
+    The server holds the workflow: which steps, in what order, under what
+    conditions, and what stops a run. This side holds your data and executes
+    what it is asked to, one operation at a time.
+
+    Neither half moves. Your prices stay on your machine and the sequencing
+    stays on the server, which is what makes the arrangement stable rather than
+    a standoff between two parties who each want the other's part.
+
+EVERYTHING ELSE IN THIS PACKAGE WORKS WITHOUT ANY OF THIS
+    `sweep`, the core maths and the study artifact need no server, no account
+    and no network. This subpackage is additive. If it is not for you, importing
+    the top level never touches it.
+"""
+
+from __future__ import annotations
+
+from .executor import StepExecutor, UnsupportedOp
+from .session import Offline, Run, ServerError, Session, connect, connect_or_offline
+
+__all__ = [
+    "connect",
+    "connect_or_offline",
+    "Session",
+    "Run",
+    "StepExecutor",
+    "UnsupportedOp",
+    "Offline",
+    "ServerError",
+]

alphaengine-0.1.2/src/alphaengine/client/executor.py

@@ -0,0 +1,236 @@
+"""The step executor: runs one operation locally and returns figures.
+
+THE HALF OF THE SPLIT THAT LIVES ON YOUR MACHINE. A workflow server tells this
+executor what to do; the executor does it against data that never leaves, and
+returns derived figures. Your prices, your returns and your parameter grid stay
+where they are.
+
+WHAT THIS DELIBERATELY DOES NOT CONTAIN
+    No graph, no router, no notion of what comes next. It executes what it is
+    handed and reports. If you find yourself wanting to add "and then usually
+    we..." to this file, that belongs to whoever is orchestrating, not here.
+    The absence is the design: an executor that knew the sequence would be a
+    second, worse copy of the server's job, and the two would drift.
+
+WHAT COMES BACK IS FIGURES, NEVER SERIES
+    Every handler returns scalars and small structures. A server that asked for
+    a return series would be refused, and none does: the whole arrangement rests
+    on the data staying put, so the client enforces its own half rather than
+    trusting the other end.
+
+THE WORKSPACE
+    Some operations read what an earlier one produced: a deflated Sharpe needs
+    the sweep's trial matrix. That intermediate stays HERE, in memory, keyed by
+    op name. The server sees the figure, never the matrix.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Callable
+from typing import Any
+
+import numpy as np
+
+from ..core import (
+    compute_var_cvar,
+    deflated_sharpe,
+    min_track_record_length,
+    pbo_cscv,
+    performance_report,
+    technical_features,
+)
+from ..sweep import sweep as run_sweep
+
+__all__ = ["StepExecutor", "UnsupportedOp", "MAX_FIGURE_LIST", "Handler"]
+
+# A figures payload: derived values, never a series. `Workspace` holds the
+# intermediates that stay on this machine (the trial matrix, most importantly).
+Figures = dict[str, Any]
+Workspace = dict[str, Any]
+Handler = Callable[[Figures, Workspace], Figures]
+
+# Mirrors the server's guard. Enforced on our side too, because "the data never
+# leaves" should not depend on the other end remembering to check.
+MAX_FIGURE_LIST = 64
+
+
+class UnsupportedOp(LookupError):
+    """This build cannot execute that operation.
+
+    Raised rather than silently skipped. A skipped step reports success on work
+    that never happened, and the figure it did not produce becomes a gap
+    somewhere downstream that nobody can trace back to here.
+    """
+
+
+def _hash(data: Any) -> str:
+    try:
+        arr = np.asarray(data, dtype=float)
+        return hashlib.sha256(np.ascontiguousarray(arr).tobytes()).hexdigest()[:16]
+    except (TypeError, ValueError):
+        blob = json.dumps(data, sort_keys=True, default=str).encode()
+        return hashlib.sha256(blob).hexdigest()[:16]
+
+
+def _n_obs(data: Any) -> int:
+    try:
+        return int(np.asarray(data, dtype=float).shape[0])
+    except (TypeError, ValueError, IndexError):
+        try:
+            return len(data)
+        except TypeError:
+            return 0
+
+
+def _guard(figures: dict[str, Any]) -> dict[str, Any]:
+    """Refuse to send anything series-shaped, whatever it is called."""
+
+    def walk(node: Any, path: str) -> None:
+        if isinstance(node, dict):
+            for k, v in node.items():
+                walk(v, f"{path}.{k}")
+        elif isinstance(node, (list, tuple)):
+            if len(node) > MAX_FIGURE_LIST:
+                raise ValueError(
+                    f"refusing to send {path}: {len(node)} elements is a series, "
+                    "not a figure. Your data stays on your machine."
+                )
+            for i, v in enumerate(node):
+                walk(v, f"{path}[{i}]")
+
+    walk(figures, "figures")
+    return figures
+
+
+class StepExecutor:
+    """Executes ops against local data.
+
+    Args:
+        data: whatever your steps operate on. Passed to your backtest function
+            untouched and never transmitted.
+        backtest_fn: your own backtest, for `compute.sweep`. We orchestrate and
+            measure; you simulate.
+        handlers: extra or overriding op handlers, as {op: callable(params,
+            workspace) -> figures}. This is the extension point for `data.*` and
+            `record.*` ops that only your environment can answer.
+    """
+
+    def __init__(
+        self,
+        *,
+        data: Any = None,
+        backtest_fn: Callable[..., Any] | None = None,
+        handlers: dict[str, Handler] | None = None,
+    ) -> None:
+        self.data = data
+        self.backtest_fn = backtest_fn
+        self.workspace: dict[str, Any] = {}
+        self._handlers: dict[str, Handler] = {
+            "data.resolve": self._resolve,
+            "data.describe": self._resolve,
+            "compute.sweep": self._sweep,
+            "compute.deflated_sharpe": self._deflated,
+            "compute.pbo_cscv": self._pbo,
+            "compute.min_track_record_length": self._mintrl,
+            "compute.performance_report": self._performance,
+            "compute.compute_var_cvar": self._var,
+            "compute.technical_features": self._technical,
+        }
+        if handlers:
+            self._handlers.update(handlers)
+
+    def supports(self, op: str) -> bool:
+        return op in self._handlers
+
+    def execute(self, op: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        handler = self._handlers.get(op)
+        if handler is None:
+            raise UnsupportedOp(
+                f"{op!r} is not executable by this build. Supply a handler for it, or upgrade alphaengine."
+            )
+        return _guard(handler(dict(params or {}), self.workspace))
+
+    # ── handlers ───────────────────────────────────────────────────────────
+    def _resolve(self, params: Figures, ws: Workspace) -> Figures:
+        """Identify the data without disclosing it.
+
+        A content hash rather than a name: a label can be changed to escape a
+        history and an array cannot, so this is what makes a run reproducible
+        without the series ever crossing.
+        """
+        return {
+            "ref": params.get("ref") or "local",
+            "hash": _hash(self.data),
+            "n_obs": _n_obs(self.data),
+        }
+
+    def _sweep(self, params: Figures, ws: Workspace) -> Figures:
+        if self.backtest_fn is None:
+            raise UnsupportedOp(
+                "compute.sweep needs your backtest function. Pass backtest_fn to "
+                "StepExecutor: we orchestrate and measure, you simulate."
+            )
+        result = run_sweep(self.backtest_fn, params.get("grid") or {}, data=self.data)
+        ws["sweep"] = result  # the trial matrix stays here
+
+        surface = result.surface()
+        return {
+            "n_trials": result.n_trials,
+            "n_trials_source": "derived_from_grid",
+            "data_hash": result.data_hash,
+            "shape": surface["shape"],
+            "share_within_20pct_of_best": surface["share_within_20pct_of_best"],
+            "best_sharpe": surface["best_sharpe"],
+            "n_ok": surface["n_ok"],
+            "n_failed": surface["n_failed"],
+        }
+
+    def _best_column(self, ws: Workspace) -> list[float]:
+        result = ws.get("sweep")
+        if result is None:
+            raise UnsupportedOp("no sweep in this run's workspace; that figure has nothing to read.")
+        column: list[float] = result.matrix[:, result.best.index].tolist()
+        return column
+
+    def _deflated(self, params: Figures, ws: Workspace) -> Figures:
+        result = ws.get("sweep")
+        # The trial count comes from the sweep that actually ran, not from the
+        # server's parameter. A count supplied from outside is a count somebody
+        # could flatter.
+        n_trials = result.n_trials if result is not None else int(params.get("n_trials") or 1)
+        out = deflated_sharpe(self._best_column(ws), n_trials=n_trials)
+        return {
+            "deflated_sharpe": out.get("deflated_sharpe"),
+            "psr_vs_zero": out.get("psr_vs_zero"),
+            "sr0_expected_max": out.get("sr0_expected_max"),
+            "verdict": out.get("verdict"),
+            "n_trials": n_trials,
+        }
+
+    def _pbo(self, params: Figures, ws: Workspace) -> Figures:
+        result = ws.get("sweep")
+        if result is None or result.matrix.shape[1] < 2:
+            # Honest rather than a number that looks like an answer: one
+            # configuration means the choice among configurations was not a
+            # choice.
+            return {"pbo": None, "note": "needs at least two configurations"}
+        out = pbo_cscv(result.matrix.tolist())
+        return {"pbo": out.get("pbo"), "verdict": out.get("verdict"), "n_configs": out.get("n_configs")}
+
+    def _mintrl(self, params: Figures, ws: Workspace) -> Figures:
+        return dict(min_track_record_length(self._best_column(ws)))
+
+    def _performance(self, params: Figures, ws: Workspace) -> Figures:
+        return dict(performance_report(self._best_column(ws)))
+
+    def _var(self, params: Figures, ws: Workspace) -> Figures:
+        out = compute_var_cvar(self._best_column(ws))
+        return {"confidence": out.get("confidence"), "parametric": out.get("parametric")}
+
+    def _technical(self, params: Figures, ws: Workspace) -> Figures:
+        out = technical_features(self.data, **params)
+        # Only the scalar readings travel; any embedded series is dropped rather
+        # than transmitted.
+        return {k: v for k, v in out.items() if not isinstance(v, (list, tuple))}