openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/optimizer/query.py

@@ -0,0 +1,257 @@
+"""Query experiments from on-disk scalar projections; do not import strategies or recompute statistics."""
+
+import json
+import sqlite3
+from contextlib import contextmanager
+from dataclasses import dataclass
+from decimal import Decimal
+
+from openbacktesting.optimizer.models import digest, encode
+from openbacktesting.optimizer.storage import (
+    check_version,
+    connect,
+    counts,
+    load_report,
+    local_path,
+)
+
+
+def _compare(left, right):
+    a, b = json.loads(left), json.loads(right)
+    if a[0] == "number":
+        a, b = Decimal(str(a[1])), Decimal(str(b[1]))
+    else:
+        a, b = a[1], b[1]
+    return (a > b) - (a < b)
+
+
+def _key(value, kind):
+    return encode([kind, json.loads(value)]) if value is not None else None
+
+
+def _status(alias):
+    return (
+        f"CASE WHEN {alias}.trial IS NULL THEN 'missing' "
+        f"ELSE COALESCE({alias}.status, CASE WHEN {alias}.kind='null' THEN 'null' ELSE 'ok' END) END"
+    )
+
+
+def _direction(path):
+    return (
+        "asc"
+        if "drawdown" in path.casefold() and not path.startswith("extensions.legacy.")
+        else "desc"
+    )
+
+
+def _limit(value):
+    if type(value) is not int or not 1 <= value <= 1000:
+        raise ValueError("optimizer: limit must be in 1..1000")
+
+
+@dataclass(frozen=True)
+class ExperimentResult:
+    """Reopenable read-only result handle; each access uses an independent connection without live strategy references."""
+
+    path: str
+    experiment_id: str
+
+    @contextmanager
+    def _connection(self):
+        conn = connect(self.path, readonly=True)
+        try:
+            check_version(conn)
+            if conn.execute("SELECT id FROM experiment").fetchone()[0] != self.experiment_id:
+                raise ValueError("optimizer: experiment ID does not match")
+            conn.create_collation("exact", _compare)
+            conn.create_function("scalar_key", 2, _key, deterministic=True)
+            conn.execute("PRAGMA temp_store=FILE")
+            yield conn
+        finally:
+            conn.close()
+
+    def info(self) -> dict:
+        """Return experiment status, category counts, and an immutable plan copy."""
+        with self._connection() as conn:
+            return counts(conn) | {
+                "plan": json.loads(conn.execute("SELECT plan FROM experiment").fetchone()[0])
+            }
+
+    def fields(self) -> list[dict]:
+        """Return scalar paths, types, units, statuses, methods, and suggested sort directions."""
+        with self._connection() as conn:
+            return [
+                dict(row) | {"suggestedDirection": _direction(row["path"])}
+                for row in conn.execute(
+                    "SELECT DISTINCT path,kind,unit,status,method FROM scalars ORDER BY path"
+                )
+            ]
+
+    def load_portfolio(self, trial_id: str) -> dict:
+        """Validate and load one complete report; explicitly reject failures and corruption."""
+        with self._connection() as conn:
+            return load_report(conn, trial_id)
+
+    def trials(self, *, limit: int = 100, offset: int = 0) -> list[dict]:
+        """Browse live statuses of all visited trials by page, without complete Portfolios."""
+        _limit(limit)
+        if type(offset) is not int or offset < 0:
+            raise ValueError("optimizer: offset must be a nonnegative integer")
+        with self._connection() as conn:
+            return [
+                dict(row)
+                for row in conn.execute(
+                    "SELECT t.id AS trial_id,t.ordinal,t.request,t.state,t.attempt,a.error FROM trials t JOIN attempts a ON a.trial=t.id AND a.number=t.attempt ORDER BY t.ordinal LIMIT ? OFFSET ?",
+                    (limit, offset),
+                )
+            ]
+
+    def query(
+        self, *, order_by=(), filters=(), fields=(), limit: int = 100, cursor: str | None = None
+    ) -> dict:
+        """Query scalar values and parameters for successful trials; cursors freeze the commit range, and new queries refresh it.
+
+        order_by is a path or (path, asc/desc); filters are (path, operator, value).
+        Supported operators: eq/ne/lt/le/gt/ge/status; escape dots and backslashes in keys with a backslash.
+        """
+        _limit(limit)
+        ordering = [
+            (item, _direction(item)) if isinstance(item, str) else tuple(item) for item in order_by
+        ]
+        if any(len(item) != 2 or item[1] not in ("asc", "desc") for item in ordering):
+            raise ValueError("optimizer: invalid sort direction")
+        operations = {"eq": "=", "ne": "!=", "lt": "<", "le": "<=", "gt": ">", "ge": ">="}
+        if any(len(item) != 3 or item[1] not in (*operations, "status") for item in filters):
+            raise ValueError("optimizer: invalid filter condition")
+        paths = list(
+            dict.fromkeys([p for p, _ in ordering] + [f[0] for f in filters] + list(fields))
+        )
+        query_hash = digest([ordering, filters, fields, limit])
+        with self._connection() as conn:
+            maximum = conn.execute("SELECT sequence FROM experiment").fetchone()[0]
+            token = (
+                json.loads(cursor)
+                if cursor is not None
+                else {
+                    "experiment": self.experiment_id,
+                    "query": query_hash,
+                    "watermark": maximum,
+                    "offset": 0,
+                }
+            )
+            if (
+                not isinstance(token, dict)
+                or token.get("experiment") != self.experiment_id
+                or token.get("query") != query_hash
+                or type(token.get("watermark")) is not int
+                or not 0 <= token["watermark"] <= maximum
+                or type(token.get("offset")) is not int
+                or token["offset"] < 0
+            ):
+                raise ValueError("optimizer: cursor does not match the query")
+            joins, selected, params, metadata = [], [], [], {}
+            for i, path in enumerate(paths):
+                rows = conn.execute(
+                    "SELECT DISTINCT kind,unit,method FROM scalars s JOIN trials t ON s.trial=t.id WHERE s.path=? AND t.sequence<=?",
+                    (path, token["watermark"]),
+                ).fetchall()
+                if not rows:
+                    raise ValueError(f"optimizer: unknown or nonscalar field {path}")
+                signatures = {
+                    (r["kind"], r["unit"], r["method"]) for r in rows if r["kind"] != "null"
+                }
+                if len(signatures) > 1 or len({(r["unit"], r["method"]) for r in rows}) > 1:
+                    raise ValueError(f"optimizer: inconsistent field types or statistical definitions {path}")
+                metadata[path] = next(iter(signatures), ("null", rows[0]["unit"], rows[0]["method"]))
+                joins.append(f"LEFT JOIN scalars s{i} ON s{i}.trial=t.id AND s{i}.path=?")
+                params.append(path)
+                selected += [f"s{i}.value AS v{i}", f"{_status(f's{i}')} AS z{i}"]
+            where = ["t.state='succeeded'", "t.sequence<=?"]
+            params.append(token["watermark"])
+            for path, op, value in filters:
+                alias = f"s{paths.index(path)}"
+                if op == "status":
+                    where.append(f"{_status(alias)}=?")
+                    params.append(value)
+                else:
+                    kind = metadata[path][0]
+                    valid = (
+                        kind == "number"
+                        and type(value) in (int, float, str)
+                        or kind == "string"
+                        and type(value) is str
+                        or kind == "boolean"
+                        and type(value) is bool
+                    )
+                    if not valid:
+                        raise ValueError("optimizer: filter value type does not match")
+                    if kind == "number":
+                        number = Decimal(str(value))
+                        if not number.is_finite():
+                            raise ValueError("optimizer: nonfinite filter value")
+                    where.append(
+                        f"scalar_key({alias}.value,{alias}.kind) COLLATE exact {operations[op]} ?"
+                    )
+                    params.append(encode([kind, value]))
+            order = []
+            for path, direction in ordering:
+                alias = f"s{paths.index(path)}"
+                order += [
+                    f"({alias}.value IS NULL) ASC",
+                    f"scalar_key({alias}.value,{alias}.kind) COLLATE exact {direction.upper()}",
+                ]
+            order.append("t.ordinal ASC")
+            columns = "t.id,t.ordinal,t.request" + ("," + ",".join(selected) if selected else "")
+            sql = f"SELECT {columns} FROM trials t {' '.join(joins)} WHERE {' AND '.join(where)} ORDER BY {','.join(order)} LIMIT ? OFFSET ?"
+            rows = conn.execute(sql, (*params, limit + 1, token["offset"])).fetchall()
+            result = [
+                {
+                    "trial_id": row["id"],
+                    "ordinal": row["ordinal"],
+                    "inputs": json.loads(row["request"])["values"],
+                    "values": {
+                        p: {
+                            "value": json.loads(row[f"v{i}"]) if row[f"v{i}"] is not None else None,
+                            "status": row[f"z{i}"],
+                            "unit": metadata[p][1],
+                            "methodId": metadata[p][2],
+                        }
+                        for i, p in enumerate(paths)
+                    },
+                }
+                for row in rows[:limit]
+            ]
+            following = (
+                encode(token | {"offset": token["offset"] + limit}) if len(rows) > limit else None
+            )
+            return {"rows": result, "cursor": following, "watermark": token["watermark"]}
+
+    def backup(self, destination) -> str:
+        """Create a consistent backup in a new local file; reject overwriting existing files."""
+        target = local_path(destination)
+        with target.open("xb"):
+            pass
+        try:
+            with self._connection() as source:
+                dest = sqlite3.connect(target)
+                try:
+                    source.backup(dest)
+                finally:
+                    dest.close()
+        except BaseException:
+            target.unlink()
+            raise
+        return str(target)
+
+
+def open_result(path, experiment_id: str | None = None) -> ExperimentResult:
+    """Open an experiment result database read-only, without strategy or market-data dependencies."""
+    conn = connect(path, readonly=True)
+    try:
+        check_version(conn)
+        current = conn.execute("SELECT id FROM experiment").fetchone()[0]
+        if experiment_id is not None and current != experiment_id:
+            raise ValueError("optimizer: experiment ID does not match")
+        return ExperimentResult(str(local_path(path)), current)
+    finally:
+        conn.close()

openbacktesting/optimizer/runner.py

@@ -0,0 +1,98 @@
+"""Execute and commit trials sequentially; file side effects occur only during explicit execution."""
+
+import sqlite3
+
+from openbacktesting.optimizer.models import OptimizationError, _ExportError
+from openbacktesting.optimizer.plan import combinations
+from openbacktesting.optimizer.query import open_result
+from openbacktesting.optimizer.storage import Store, counts, owner
+from openbacktesting.optimizer.validation import validate_report
+
+
+def execute(
+    plan_value,
+    executor,
+    path,
+    *,
+    experiment_id=None,
+    constraint=None,
+    cancel=None,
+    on_progress=None,
+):
+    """Execute or resume a plan; executor receives title-based requests and returns complete Portfolio dictionaries.
+
+    Constraints receive complete wire values; cancel is a no-argument bool callable, and on_progress only consumes notifications.
+    Only an explicit experiment_id indicates resumption; failed trials are not retried automatically.
+    """
+    if (constraint is None) != (plan_value.snapshot()["constraintId"] is None):
+        raise ValueError("optimizer: constraint does not match the plan digest")
+    committed = 0
+    store = None
+    try:
+        with owner(path):
+            store = Store(path, plan_value, experiment_id=experiment_id)
+            experiment_id = store.id
+            try:
+                committed = counts(store.conn)["committed"]
+                for ordinal, request in combinations(plan_value):
+                    if cancel is not None and cancel():
+                        store.finish("cancelled")
+                        break
+                    attempt = store.start(ordinal, request)
+                    if attempt is None:
+                        continue
+                    trial_id, number = attempt
+                    if constraint is not None:
+                        try:
+                            accepted = constraint(dict(request["values"]))
+                            if type(accepted) is not bool:
+                                raise TypeError("optimizer: constraint must return bool")
+                        except Exception as error:
+                            store.state(
+                                trial_id,
+                                number,
+                                "failed",
+                                f"constraint: {type(error).__name__}: {str(error)[:2000]}",
+                            )
+                            raise
+                        if not accepted:
+                            store.state(trial_id, number, "skipped_constraint", "constraint_false")
+                            continue
+                    phase = "execution"
+                    try:
+                        report = executor(request)
+                        phase = "export"
+                        validate_report(report)
+                    except Exception as error:  # noqa: BLE001 — isolate arbitrary user strategy/export exceptions and record failures
+                        store.state(
+                            trial_id,
+                            number,
+                            "failed",
+                            f"{'export' if isinstance(error, _ExportError) else phase}: {type(error).__name__}: {str(error)[:2000]}",
+                        )
+                    else:
+                        store.state(trial_id, number, "persisting")
+                        store.commit(trial_id, number, report)
+                        del report
+                        committed += 1
+                        if on_progress is not None:
+                            on_progress(
+                                counts(store.conn)
+                                | {"event": "trial_committed", "trial_id": trial_id}
+                            )
+                else:
+                    store.finish(
+                        "completed_with_errors" if counts(store.conn)["failed"] else "completed"
+                    )
+            except BaseException as failure:
+                try:
+                    store.finish("failed")
+                except sqlite3.Error as status_error:
+                    failure.add_note(f"Failed to persist experiment failure status: {status_error}")
+                raise
+            finally:
+                store.close()
+    except Exception as error:
+        message = str(error) + " ".join(getattr(error, "__notes__", ()))
+        raise OptimizationError(message, path, experiment_id, committed) from error
+    return open_result(path, experiment_id)

openbacktesting/optimizer/storage.py

@@ -0,0 +1,261 @@
+"""Local single-experiment SQLite result database; one report corresponds to one atomic commit."""
+
+import hashlib
+import json
+import re
+import sqlite3
+from contextlib import contextmanager
+from datetime import UTC, datetime
+from pathlib import Path
+from uuid import uuid4
+
+from openbacktesting.optimizer.models import encode
+from openbacktesting.optimizer.validation import validate_report
+
+APPLICATION_ID = 1128546128
+VERSION = 1
+DDL = """
+CREATE TABLE experiment(id TEXT PRIMARY KEY, plan TEXT NOT NULL, status TEXT NOT NULL,
+                       sequence INTEGER NOT NULL DEFAULT 0);
+CREATE TABLE trials(id TEXT PRIMARY KEY, ordinal INTEGER UNIQUE NOT NULL,
+ request TEXT NOT NULL UNIQUE, state TEXT NOT NULL, attempt INTEGER NOT NULL,
+ sequence INTEGER UNIQUE, report TEXT, hash TEXT);
+CREATE TABLE attempts(trial TEXT NOT NULL REFERENCES trials(id), number INTEGER NOT NULL,
+ state TEXT NOT NULL, started TEXT NOT NULL, ended TEXT, error TEXT,
+ PRIMARY KEY(trial,number));
+CREATE TABLE scalars(trial TEXT NOT NULL REFERENCES trials(id), path TEXT NOT NULL,
+ value TEXT, kind TEXT NOT NULL, unit TEXT, status TEXT, method TEXT,
+ PRIMARY KEY(trial,path));
+CREATE INDEX scalar_path ON scalars(path);
+"""
+
+
+def local_path(path):
+    raw = str(path)
+    if raw.startswith(("file:", "//", "\\\\")) or raw == ":memory:":
+        raise ValueError("optimizer: a local file path is required")
+    return Path(path).expanduser().resolve()
+
+
+def connect(path, *, readonly=False):
+    path = local_path(path)
+    conn = sqlite3.connect(
+        path.as_uri() + ("?mode=ro" if readonly else "?mode=rwc"), uri=True, timeout=1
+    )
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys=ON")
+    if readonly:
+        conn.execute("PRAGMA query_only=ON")
+    return conn
+
+
+def check_version(conn):
+    if (
+        conn.execute("PRAGMA application_id").fetchone()[0] != APPLICATION_ID
+        or conn.execute("PRAGMA user_version").fetchone()[0] != VERSION
+    ):
+        raise ValueError("optimizer: unsupported result database version")
+
+
+@contextmanager
+def owner(path):
+    """Separate lock database holding an operating-system file lock without blocking result database readers."""
+    path = local_path(path)
+    lock = sqlite3.connect(str(path) + ".owner", timeout=0)
+    try:
+        lock.execute("BEGIN EXCLUSIVE")
+        yield path
+    finally:
+        lock.close()
+
+
+def now():
+    return datetime.now(UTC).isoformat()
+
+
+def flatten(value, path="", metadata=None):
+    """Scalar projection; escape dots/backslashes in keys with a backslash, and do not traverse arrays."""
+    if isinstance(value, dict):
+        if {"value", "unit", "status", "methodId"} <= value.keys():
+            metadata = value
+        elif value.get("kind") in ("aware", "naive") and "value" in value:
+            metadata = {"unit": "ns"}
+        for key, child in value.items():
+            part = key.replace("\\", "\\\\").replace(".", "\\.")
+            yield from flatten(
+                child, f"{path}.{part}" if path else part, metadata if key == "value" else None
+            )
+    elif not isinstance(value, list):
+        meta = metadata or {}
+        if path.casefold().endswith(("durationns", ".ns")):
+            meta = meta | {"unit": "ns"}
+        kind = {str: "string", int: "number", float: "number", bool: "boolean", type(None): "null"}[
+            type(value)
+        ]
+        if (
+            isinstance(value, str)
+            and re.fullmatch(r"-?\d+", value)
+            and (metadata is not None or meta.get("unit") == "ns")
+        ):
+            kind = "number"
+        yield (
+            path,
+            None if value is None else encode(value),
+            kind,
+            meta.get("unit"),
+            meta.get("status"),
+            meta.get("methodId"),
+        )
+
+
+class Store:
+    def __init__(self, path, plan_value, *, experiment_id=None):
+        self.path = local_path(path)
+        self.conn = connect(path)
+        try:
+            if experiment_id is None:
+                if self.conn.execute(
+                    "SELECT name FROM sqlite_master WHERE type='table'"
+                ).fetchone():
+                    raise FileExistsError("optimizer: database already contains an experiment; resume explicitly or use a new path")
+                self.conn.executescript(DDL)
+                self.conn.execute(f"PRAGMA application_id={APPLICATION_ID}")
+                self.conn.execute(f"PRAGMA user_version={VERSION}")
+                self.id = uuid4().hex
+                self.conn.execute(
+                    "INSERT INTO experiment(id,plan,status) VALUES(?,?,'running')",
+                    (self.id, plan_value._json),
+                )
+                self.conn.commit()
+            else:
+                check_version(self.conn)
+                row = self.conn.execute(
+                    "SELECT * FROM experiment WHERE id=?", (experiment_id,)
+                ).fetchone()
+                if row is None or row["plan"] != plan_value._json:
+                    raise ValueError("optimizer: experiment identity or plan does not match")
+                self.id = experiment_id
+            mode = self.conn.execute("PRAGMA journal_mode=WAL").fetchone()[0]
+            self.conn.execute("PRAGMA synchronous=FULL")
+            if mode != "wal" or self.conn.execute("PRAGMA synchronous").fetchone()[0] != 2:
+                raise RuntimeError("optimizer: unable to enable local durability policy")
+            with self.conn:
+                self.conn.execute(
+                    "UPDATE attempts SET state='interrupted',ended=? WHERE state IN ('running','persisting')",
+                    (now(),),
+                )
+                self.conn.execute(
+                    "UPDATE trials SET state='interrupted' WHERE state IN ('running','persisting')"
+                )
+                self.conn.execute("UPDATE experiment SET status='running'")
+        except BaseException:
+            self.conn.close()
+            raise
+
+    def close(self):
+        self.conn.close()
+
+    def start(self, ordinal, request):
+        trial_id = f"{self.id}:{ordinal}"
+        row = self.conn.execute("SELECT * FROM trials WHERE id=?", (trial_id,)).fetchone()
+        if row and row["state"] in ("succeeded", "failed", "skipped_constraint"):
+            return None
+        attempt = row["attempt"] + 1 if row else 1
+        with self.conn:
+            self.conn.execute(
+                "INSERT INTO trials(id,ordinal,request,state,attempt) VALUES(?,?,?,'running',?) ON CONFLICT(id) DO UPDATE SET state='running',attempt=excluded.attempt",
+                (trial_id, ordinal, encode(request), attempt),
+            )
+            self.conn.execute(
+                "INSERT INTO attempts(trial,number,state,started) VALUES(?,?,'running',?)",
+                (trial_id, attempt, now()),
+            )
+        return trial_id, attempt
+
+    def state(self, trial_id, attempt, state, error=None):
+        with self.conn:
+            count = self.conn.execute(
+                "UPDATE trials SET state=? WHERE id=? AND attempt=? AND state IN ('running','persisting')",
+                (state, trial_id, attempt),
+            ).rowcount
+            if count != 1:
+                raise ValueError("optimizer: stale trial attempt")
+            self.conn.execute(
+                "UPDATE attempts SET state=?,ended=?,error=? WHERE trial=? AND number=?",
+                (state, None if state == "persisting" else now(), error, trial_id, attempt),
+            )
+
+    def commit(self, trial_id, attempt, report):
+        validate_report(report)
+        payload = encode(report)
+        checksum = hashlib.sha256(payload.encode()).hexdigest()
+        row = self.conn.execute("SELECT * FROM trials WHERE id=?", (trial_id,)).fetchone()
+        if row is None or row["attempt"] != attempt:
+            raise ValueError("optimizer: stale trial attempt")
+        if row["state"] == "succeeded":
+            if row["hash"] != checksum:
+                raise ValueError("optimizer: committed report content conflicts")
+            return
+        if row["state"] != "persisting":
+            raise ValueError("optimizer: trial has not produced a complete report")
+        request = json.loads(row["request"])
+        inputs = report["context"]["inputs"]
+        if inputs is None or any(inputs.get(k) != v for k, v in request.items()):
+            raise ValueError("optimizer: Portfolio parameters do not match the trial")
+        execution = json.loads(self.conn.execute("SELECT plan FROM experiment").fetchone()[0])[
+            "execution"
+        ]
+        expected = execution.get("backtest")
+        if expected is not None:
+            actual = report["context"]["backtest"]
+            if actual is None or any(actual.get(k) != v for k, v in expected.items()):
+                raise ValueError("optimizer: Portfolio configuration does not match the experiment")
+        with self.conn:
+            self.conn.execute("UPDATE experiment SET sequence=sequence+1")
+            sequence = self.conn.execute("SELECT sequence FROM experiment").fetchone()[0]
+            self.conn.execute(
+                "UPDATE trials SET state='succeeded',sequence=?,report=?,hash=? WHERE id=?",
+                (sequence, payload, checksum, trial_id),
+            )
+            self.conn.executemany(
+                "INSERT INTO scalars VALUES(?,?,?,?,?,?,?)",
+                ((trial_id, *item) for item in flatten(report)),
+            )
+            self.conn.execute(
+                "UPDATE attempts SET state='succeeded',ended=? WHERE trial=? AND number=?",
+                (now(), trial_id, attempt),
+            )
+
+    def finish(self, state):
+        with self.conn:
+            self.conn.execute("UPDATE experiment SET status=?", (state,))
+
+
+def load_report(conn, trial_id):
+    row = conn.execute("SELECT report,hash,state FROM trials WHERE id=?", (trial_id,)).fetchone()
+    if row is None or row["state"] != "succeeded":
+        raise ValueError("optimizer: this trial has no committed Portfolio")
+    if hashlib.sha256(row["report"].encode()).hexdigest() != row["hash"]:
+        raise ValueError("optimizer: Portfolio content verification failed")
+    return validate_report(json.loads(row["report"]))
+
+
+def counts(conn):
+    experiment = conn.execute("SELECT * FROM experiment").fetchone()
+    states = dict(conn.execute("SELECT state,COUNT(*) FROM trials GROUP BY state").fetchall())
+    total = json.loads(experiment["plan"])["total"]
+    committed = states.get("succeeded", 0)
+    skipped = states.get("skipped_constraint", 0)
+    failed = states.get("failed", 0)
+    return {
+        "experiment_id": experiment["id"],
+        "status": experiment["status"],
+        "total": total,
+        "checked": sum(states.values()),
+        "committed": committed,
+        "skipped": skipped,
+        "failed": failed,
+        "running": states.get("running", 0),
+        "computed": committed + states.get("persisting", 0),
+        "remaining": total - committed - skipped - failed,
+    }

openbacktesting/optimizer/validation.py

@@ -0,0 +1,64 @@
+"""Validate Portfolio against the single generated schema; the standalone kernel does not depend on the protocol package."""
+
+import json
+from functools import lru_cache
+from pathlib import Path
+
+from openbacktesting.optimizer._semantics import check_portfolio
+from openbacktesting.optimizer.models import encode
+
+
+@lru_cache(maxsize=1)
+def _schema():
+    return json.loads(Path(__file__).with_name("portfolio-result.schema.json").read_text())
+
+
+def _valid(value, schema):
+    if "$ref" in schema:
+        return _valid(value, _schema()["$defs"][schema["$ref"].rsplit("/", 1)[1]])
+    for key in ("anyOf", "oneOf"):
+        if key in schema:
+            count = sum(_valid(value, child) for child in schema[key])
+            if not (count == 1 if key == "oneOf" else count > 0):
+                return False
+    if "const" in schema and value != schema["const"]:
+        return False
+    if "enum" in schema and value not in schema["enum"]:
+        return False
+    kind = {
+        dict: "object",
+        list: "array",
+        str: "string",
+        bool: "boolean",
+        int: "integer",
+        float: "number",
+        type(None): "null",
+    }[type(value)]
+    types = schema.get("type", [kind])
+    types = [types] if isinstance(types, str) else types
+    if kind not in types and not (kind == "integer" and "number" in types):
+        return False
+    if isinstance(value, dict):
+        props = schema.get("properties", {})
+        extra = schema.get("additionalProperties", {})
+        if not set(schema.get("required", ())).issubset(value):
+            return False
+        for key, item in value.items():
+            if key not in props and extra is False:
+                return False
+            if not _valid(item, props.get(key, extra)):
+                return False
+    if isinstance(value, list):
+        if not schema.get("minItems", 0) <= len(value) <= schema.get("maxItems", len(value)):
+            return False
+        if not all(_valid(item, schema.get("items", {})) for item in value):
+            return False
+    return True
+
+
+def validate_report(report):
+    encode(report)
+    if not _valid(report, _schema()):
+        raise ValueError("optimizer: invalid Portfolio structure or version")
+    check_portfolio(report)
+    return report