timoshenko-engine 2.0.1__py3-none-any.whl

timoshenko/stability.py

@@ -0,0 +1,30 @@
+"""Ideal elastic column stability formulas (not member design checks)."""
+
+from __future__ import annotations
+
+import math
+
+
+def euler_critical_load(youngs_modulus_pa: float, second_moment_m4: float,
+                        length_m: float, effective_length_factor: float = 1.0) -> float:
+    """Euler elastic critical load ``pi^2 E I / (K L)^2`` in newtons.
+
+    The caller selects ``K`` for the actual restraint and buckling axis.
+    ``K=1`` is the ideal pin-pin case. The equation assumes a straight,
+    prismatic, slender, perfectly elastic column with ideal axial loading.
+    """
+    e, inertia, length, factor = map(float, (youngs_modulus_pa, second_moment_m4, length_m, effective_length_factor))
+    if not all(math.isfinite(v) and v > 0.0 for v in (e, inertia, length, factor)):
+        raise ValueError("E, I, length, and effective length factor must be finite and positive")
+    effective_length = factor * length
+    return math.pi**2 * e * inertia / effective_length**2
+
+
+def slenderness_ratio(length_m: float, effective_length_factor: float,
+                      area_m2: float, second_moment_m4: float) -> float:
+    """Geometric slenderness ``K L / r_g`` for one selected buckling axis."""
+    length, factor, area, inertia = map(float, (length_m, effective_length_factor, area_m2, second_moment_m4))
+    if not all(math.isfinite(v) and v > 0.0 for v in (length, factor, area, inertia)):
+        raise ValueError("length, factor, area, and second moment must be finite and positive")
+    radius_gyration = math.sqrt(inertia / area)
+    return factor * length / radius_gyration

timoshenko/storage.py

@@ -0,0 +1,413 @@
+"""Small local SQLite asset, observation, and analysis history store."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+import json
+import hashlib
+import math
+from pathlib import Path
+import sqlite3
+from typing import TYPE_CHECKING, Any, Literal
+import uuid
+
+from .assets import Asset, Relation
+from .observations import Observation, ObservationBatch
+
+if TYPE_CHECKING:
+    # Only for annotations: importing the project runner at module level would
+    # make this low-level store depend on the whole analysis stack.
+    from .project import ProjectRunResult
+
+
+_SCHEMA_VERSION = 1
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="microseconds")
+
+
+def _json(value: Any) -> str:
+    try:
+        return json.dumps(value, ensure_ascii=False, sort_keys=True, allow_nan=False, separators=(",", ":"))
+    except (TypeError, ValueError) as error:
+        raise ValueError(f"value is not JSON-serializable: {error}") from None
+
+
+def _batch_digest(batch: ObservationBatch) -> str:
+    if not isinstance(batch, ObservationBatch):
+        raise TypeError("batch must be an ObservationBatch")
+    if not batch.batch_id.strip() or not batch.source_id.strip():
+        raise ValueError("batch_id and source_id are required for idempotent persistence")
+    serialized = _json([item.to_dict() for item in batch.observations])
+    return hashlib.sha256(serialized.encode("utf-8")).hexdigest()
+
+
+@dataclass(frozen=True)
+class BatchAppendResult:
+    batch_id: str
+    source_id: str
+    inserted_count: int
+    duplicate_count: int
+    duplicate_batch: bool
+
+    @property
+    def was_duplicate(self) -> bool:
+        return self.duplicate_batch
+
+
+class SQLiteStore:
+    """A one-process local history store backed by Python's SQLite module.
+
+    Batch ingestion is idempotent for the unique ``(source_id, batch_id)``
+    pair. Observations retain arrival order and timestamps as supplied. Reads
+    can choose arrival or event-time order; this class does not interpolate,
+    delete late values, or infer missing values.
+    """
+
+    def __init__(self, path: str | Path, *, timeout_seconds: float = 5.0):
+        self.path = str(path)
+        if self.path != ":memory:":
+            db_path = Path(self.path).expanduser().resolve()
+            db_path.parent.mkdir(parents=True, exist_ok=True)
+            self.path = str(db_path)
+        timeout = float(timeout_seconds)
+        if not math.isfinite(timeout) or timeout <= 0.0:
+            raise ValueError("timeout_seconds must be finite and positive")
+        self._connection = sqlite3.connect(self.path, timeout=timeout)
+        self._connection.row_factory = sqlite3.Row
+        self._db.execute("PRAGMA foreign_keys = ON")
+        self._initialize()
+
+    def _initialize(self) -> None:
+        version = int(self._db.execute("PRAGMA user_version").fetchone()[0])
+        if version > _SCHEMA_VERSION:
+            self.close()
+            raise RuntimeError(f"database schema {version} is newer than supported schema {_SCHEMA_VERSION}")
+        if version == _SCHEMA_VERSION:
+            return
+        with self._db:
+            self._db.executescript(
+                """
+                CREATE TABLE IF NOT EXISTS assets (
+                    asset_id TEXT PRIMARY KEY,
+                    asset_type TEXT NOT NULL,
+                    name TEXT NOT NULL,
+                    metadata_json TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+                CREATE TABLE IF NOT EXISTS relations (
+                    source_asset_id TEXT NOT NULL REFERENCES assets(asset_id) ON DELETE CASCADE,
+                    relation_type TEXT NOT NULL,
+                    target_asset_id TEXT NOT NULL REFERENCES assets(asset_id) ON DELETE CASCADE,
+                    metadata_json TEXT NOT NULL,
+                    PRIMARY KEY (source_asset_id, relation_type, target_asset_id)
+                );
+                CREATE TABLE IF NOT EXISTS observation_batches (
+                    source_id TEXT NOT NULL,
+                    batch_id TEXT NOT NULL,
+                    item_count INTEGER NOT NULL,
+                    batch_digest TEXT NOT NULL,
+                    received_at TEXT NOT NULL,
+                    PRIMARY KEY (source_id, batch_id)
+                );
+                CREATE TABLE IF NOT EXISTS observations (
+                    observation_row_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    source_id TEXT NOT NULL,
+                    batch_id TEXT NOT NULL,
+                    record_index INTEGER NOT NULL,
+                    sensor_id TEXT NOT NULL,
+                    name TEXT NOT NULL,
+                    unit TEXT NOT NULL,
+                    value REAL NOT NULL,
+                    event_timestamp REAL,
+                    quality INTEGER NOT NULL,
+                    asset_id TEXT,
+                    observation_source_id TEXT,
+                    metadata_json TEXT NOT NULL,
+                    ingested_at TEXT NOT NULL,
+                    UNIQUE (source_id, batch_id, record_index)
+                );
+                CREATE INDEX IF NOT EXISTS observations_sensor_event_idx
+                    ON observations (sensor_id, event_timestamp, observation_row_id);
+                CREATE INDEX IF NOT EXISTS observations_asset_event_idx
+                    ON observations (asset_id, event_timestamp, observation_row_id);
+                CREATE TABLE IF NOT EXISTS analysis_runs (
+                    run_id TEXT PRIMARY KEY,
+                    project_id TEXT NOT NULL,
+                    method TEXT NOT NULL,
+                    source_sha256 TEXT NOT NULL,
+                    manifest_sha256 TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    result_json TEXT NOT NULL
+                );
+                PRAGMA user_version = 1;
+                """
+            )
+
+    @property
+    def _db(self) -> sqlite3.Connection:
+        connection = getattr(self, "_connection", None)
+        if connection is None:
+            raise RuntimeError("SQLiteStore is closed")
+        return connection
+
+    def close(self) -> None:
+        if getattr(self, "_connection", None) is not None:
+            self._connection.close()
+            self._connection = None
+
+    def __enter__(self) -> "SQLiteStore":
+        if self._connection is None:
+            raise RuntimeError("store is closed")
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        self.close()
+
+    def upsert_asset(self, asset: Asset) -> None:
+        if not isinstance(asset, Asset):
+            raise TypeError("asset must be an Asset")
+        with self._db:
+            self._db.execute(
+                """INSERT INTO assets(asset_id, asset_type, name, metadata_json, updated_at)
+                   VALUES (?, ?, ?, ?, ?)
+                   ON CONFLICT(asset_id) DO UPDATE SET asset_type=excluded.asset_type,
+                     name=excluded.name, metadata_json=excluded.metadata_json, updated_at=excluded.updated_at""",
+                (asset.asset_id, asset.asset_type, asset.name, _json(asset.metadata), _utc_now()),
+            )
+
+    def get_asset(self, asset_id: str) -> Asset | None:
+        row = self._db.execute("SELECT * FROM assets WHERE asset_id=?", (str(asset_id),)).fetchone()
+        if row is None:
+            return None
+        return Asset(row["asset_id"], row["asset_type"], row["name"], json.loads(row["metadata_json"]))
+
+    def list_assets(self, *, asset_type: str | None = None) -> tuple[Asset, ...]:
+        if asset_type is None:
+            rows = self._db.execute("SELECT * FROM assets ORDER BY asset_id").fetchall()
+        else:
+            rows = self._db.execute("SELECT * FROM assets WHERE asset_type=? ORDER BY asset_id", (asset_type,)).fetchall()
+        return tuple(Asset(row["asset_id"], row["asset_type"], row["name"], json.loads(row["metadata_json"])) for row in rows)
+
+    def add_relation(self, relation: Relation) -> None:
+        if not isinstance(relation, Relation):
+            raise TypeError("relation must be a Relation")
+        with self._db:
+            self._db.execute(
+                """INSERT INTO relations(source_asset_id, relation_type, target_asset_id, metadata_json)
+                   VALUES (?, ?, ?, ?)
+                   ON CONFLICT(source_asset_id, relation_type, target_asset_id)
+                   DO UPDATE SET metadata_json=excluded.metadata_json""",
+                (relation.source_asset_id, relation.relation_type, relation.target_asset_id, _json(relation.metadata)),
+            )
+
+    def relations_for(self, asset_id: str) -> tuple[Relation, ...]:
+        rows = self._db.execute(
+            "SELECT * FROM relations WHERE source_asset_id=? OR target_asset_id=? ORDER BY relation_type, source_asset_id, target_asset_id",
+            (str(asset_id), str(asset_id)),
+        ).fetchall()
+        return tuple(Relation(row["source_asset_id"], row["relation_type"], row["target_asset_id"], json.loads(row["metadata_json"])) for row in rows)
+
+    def has_batch(self, batch: ObservationBatch) -> bool:
+        """Return whether this exact batch is already stored.
+
+        Raises ``ValueError`` when the ``(source_id, batch_id)`` pair is stored
+        with different content, exactly as :meth:`append_batch` would.
+        """
+        batch_digest = _batch_digest(batch)
+        existing = self._db.execute(
+            "SELECT batch_digest FROM observation_batches WHERE source_id=? AND batch_id=?",
+            (batch.source_id, batch.batch_id),
+        ).fetchone()
+        if existing is None:
+            return False
+        if existing["batch_digest"] != batch_digest:
+            raise ValueError("batch_id was already stored with different observation content")
+        return True
+
+    def append_batch(self, batch: ObservationBatch) -> BatchAppendResult:
+        batch_digest = _batch_digest(batch)
+        inserted = 0
+        with self._db:
+            cursor = self._db.execute(
+                "INSERT OR IGNORE INTO observation_batches(source_id, batch_id, item_count, batch_digest, received_at) VALUES (?, ?, ?, ?, ?)",
+                (batch.source_id, batch.batch_id, batch.count, batch_digest, _utc_now()),
+            )
+            is_new = cursor.rowcount == 1
+            if not is_new:
+                existing = self._db.execute(
+                    "SELECT batch_digest FROM observation_batches WHERE source_id=? AND batch_id=?",
+                    (batch.source_id, batch.batch_id),
+                ).fetchone()
+                if existing is None or existing["batch_digest"] != batch_digest:
+                    raise ValueError("batch_id was already stored with different observation content")
+            if is_new:
+                for record_index, observation in enumerate(batch.observations):
+                    self._db.execute(
+                        """INSERT INTO observations(
+                            source_id, batch_id, record_index, sensor_id, name, unit, value,
+                            event_timestamp, quality, asset_id, observation_source_id, metadata_json, ingested_at
+                        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                        (
+                            batch.source_id,
+                            batch.batch_id,
+                            record_index,
+                            observation.sensor_id,
+                            observation.name,
+                            observation.unit,
+                            observation.value,
+                            observation.timestamp,
+                            int(observation.quality),
+                            observation.asset_id,
+                            observation.source_id or batch.source_id,
+                            _json(observation.metadata),
+                            _utc_now(),
+                        ),
+                    )
+                    inserted += 1
+        duplicate = 0 if is_new else batch.count
+        return BatchAppendResult(batch.batch_id, batch.source_id, inserted, duplicate, not is_new)
+
+    def observations(
+        self,
+        *,
+        sensor_id: str | None = None,
+        asset_id: str | None = None,
+        start_timestamp: float | None = None,
+        end_timestamp: float | None = None,
+        order_by: Literal["event_time", "arrival"] = "event_time",
+        limit: int | None = None,
+    ) -> tuple[Observation, ...]:
+        if order_by not in {"event_time", "arrival"}:
+            raise ValueError("order_by must be 'event_time' or 'arrival'")
+        clauses: list[str] = []
+        parameters: list[Any] = []
+        if sensor_id is not None:
+            clauses.append("sensor_id=?")
+            parameters.append(str(sensor_id))
+        if asset_id is not None:
+            clauses.append("asset_id=?")
+            parameters.append(str(asset_id))
+        if start_timestamp is not None:
+            start = float(start_timestamp)
+            if not math.isfinite(start):
+                raise ValueError("start_timestamp must be finite")
+            clauses.append("event_timestamp>=?")
+            parameters.append(start)
+        if end_timestamp is not None:
+            end = float(end_timestamp)
+            if not math.isfinite(end):
+                raise ValueError("end_timestamp must be finite")
+            clauses.append("event_timestamp<=?")
+            parameters.append(end)
+        if start_timestamp is not None and end_timestamp is not None and start > end:
+            raise ValueError("start_timestamp must be less than or equal to end_timestamp")
+        ordering = "event_timestamp IS NULL, event_timestamp, observation_row_id" if order_by == "event_time" else "observation_row_id"
+        sql = "SELECT * FROM observations" + (" WHERE " + " AND ".join(clauses) if clauses else "") + " ORDER BY " + ordering
+        if limit is not None:
+            if int(limit) < 1:
+                raise ValueError("limit must be positive")
+            sql += " LIMIT ?"
+            parameters.append(int(limit))
+        rows = self._db.execute(sql, parameters).fetchall()
+        return tuple(
+            Observation(
+                sensor_id=row["sensor_id"],
+                name=row["name"],
+                unit=row["unit"],
+                value=row["value"],
+                timestamp=row["event_timestamp"],
+                quality=bool(row["quality"]),
+                asset_id=row["asset_id"],
+                source_id=row["observation_source_id"],
+                metadata=json.loads(row["metadata_json"]),
+            )
+            for row in rows
+        )
+
+    def recent_observations(
+        self,
+        *,
+        sensor_id: str,
+        limit: int,
+        unit: str | None = None,
+    ) -> tuple[Observation, ...]:
+        """Return a bounded event-time tail for one sensor, oldest first.
+
+        Only timestamped, good-quality observations are eligible. This is a
+        history query, not a resampler; consumers must still check the sample
+        grid and continuity of the returned records.
+        """
+        count = int(limit)
+        if count < 1 or count > 262_144:
+            raise ValueError("limit must be between 1 and 262144")
+        clauses = ["sensor_id=?", "quality=1", "event_timestamp IS NOT NULL"]
+        parameters: list[Any] = [str(sensor_id)]
+        if unit is not None:
+            clauses.append("unit=?")
+            parameters.append(str(unit))
+        parameters.append(count)
+        rows = self._db.execute(
+            "SELECT * FROM (SELECT * FROM observations WHERE "
+            + " AND ".join(clauses)
+            + " ORDER BY event_timestamp DESC, observation_row_id DESC LIMIT ?) "
+            + "ORDER BY event_timestamp ASC, observation_row_id ASC",
+            parameters,
+        ).fetchall()
+        return tuple(
+            Observation(
+                sensor_id=row["sensor_id"],
+                name=row["name"],
+                unit=row["unit"],
+                value=row["value"],
+                timestamp=row["event_timestamp"],
+                quality=True,
+                asset_id=row["asset_id"],
+                source_id=row["observation_source_id"],
+                metadata=json.loads(row["metadata_json"]),
+            )
+            for row in rows
+        )
+
+    def save_run(self, result: ProjectRunResult, *, run_id: str | None = None) -> str:
+        from .project import ProjectRunResult
+
+        if not isinstance(result, ProjectRunResult):
+            raise TypeError("result must be a ProjectRunResult")
+        identifier = str(run_id or uuid.uuid4()).strip()
+        if not identifier:
+            raise ValueError("run_id must be non-empty")
+        with self._db:
+            self._db.execute(
+                """INSERT INTO analysis_runs(
+                     run_id, project_id, method, source_sha256, manifest_sha256, created_at, result_json
+                   ) VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                (
+                    identifier,
+                    result.project_id,
+                    result.method,
+                    result.source_sha256,
+                    result.manifest_sha256,
+                    _utc_now(),
+                    _json(result.to_dict()),
+                ),
+            )
+        return identifier
+
+    def get_run(self, run_id: str) -> dict[str, Any] | None:
+        row = self._db.execute("SELECT result_json FROM analysis_runs WHERE run_id=?", (str(run_id),)).fetchone()
+        return None if row is None else json.loads(row["result_json"])
+
+    def list_runs(self, *, project_id: str | None = None, limit: int = 100) -> tuple[dict[str, Any], ...]:
+        if int(limit) < 1:
+            raise ValueError("limit must be positive")
+        if project_id is None:
+            rows = self._db.execute("SELECT result_json FROM analysis_runs ORDER BY created_at DESC, run_id DESC LIMIT ?", (int(limit),)).fetchall()
+        else:
+            rows = self._db.execute(
+                "SELECT result_json FROM analysis_runs WHERE project_id=? ORDER BY created_at DESC, run_id DESC LIMIT ?",
+                (str(project_id), int(limit)),
+            ).fetchall()
+        return tuple(json.loads(row["result_json"]) for row in rows)

timoshenko/strength.py

@@ -0,0 +1,29 @@
+"""Plane-stress transformations for homogeneous linear elasticity."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+
+
+@dataclass(frozen=True)
+class PlaneStressResult:
+    principal_max_pa: float
+    principal_min_pa: float
+    maximum_in_plane_shear_pa: float
+    von_mises_pa: float
+
+
+def plane_stress(sigma_x_pa: float, sigma_y_pa: float, tau_xy_pa: float) -> PlaneStressResult:
+    """Return principal stresses, in-plane max shear, and plane-stress von Mises.
+
+    The third principal stress is assumed zero (plane stress). No material
+    yield criterion, failure probability, or allowable stress is applied.
+    """
+    sx, sy, txy = map(float, (sigma_x_pa, sigma_y_pa, tau_xy_pa))
+    if not all(math.isfinite(v) for v in (sx, sy, txy)):
+        raise ValueError("stress components must be finite")
+    center = (sx + sy) / 2.0
+    radius = math.hypot((sx - sy) / 2.0, txy)
+    von_mises = math.sqrt(max(0.0, sx**2 - sx * sy + sy**2 + 3.0 * txy**2))
+    return PlaneStressResult(center + radius, center - radius, radius, von_mises)

timoshenko/structure.py

@@ -0,0 +1,103 @@
+"""Simple structural models used by Timoshenko's first release.
+
+Version 0.1 implements a linear lumped-mass shear-building model. It is a
+reference model for modal comparison, not a general purpose FEM solver.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+import math
+from typing import Sequence
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class Structure:
+    """A shear-building model with one lateral degree of freedom per floor.
+
+    ``story_masses_kg[i]`` and ``story_stiffness_n_m[i]`` describe floor i,
+    ordered from the base upward. Supply a measured baseline frequency list
+    when an analytical model baseline is not available.
+    """
+
+    story_masses_kg: tuple[float, ...] | Sequence[float]
+    story_stiffness_n_m: tuple[float, ...] | Sequence[float]
+    structure_id: str = "structure"
+    name: str = ""
+    reference_frequencies_hz: tuple[float, ...] = ()
+    observed_frequencies_hz: tuple[float, ...] = ()
+    update_scale_factor: float | None = None
+    update_mode_count: int = 0
+    update_mode_scale_spread_pct: float | None = None
+    update_status: str = "not_updated"
+
+    def __post_init__(self) -> None:
+        masses = tuple(float(value) for value in self.story_masses_kg)
+        stiffnesses = tuple(float(value) for value in self.story_stiffness_n_m)
+        if not masses or len(masses) != len(stiffnesses):
+            raise ValueError("story_masses_kg and story_stiffness_n_m must have the same non-zero length")
+        if any(not math.isfinite(value) or value <= 0.0 for value in masses):
+            raise ValueError("story masses must be finite positive values in kilograms")
+        if any(not math.isfinite(value) or value <= 0.0 for value in stiffnesses):
+            raise ValueError("story stiffnesses must be finite positive values in newtons per metre")
+        reference = tuple(float(value) for value in self.reference_frequencies_hz)
+        observed = tuple(float(value) for value in self.observed_frequencies_hz)
+        for label, values in (("reference", reference), ("observed", observed)):
+            if any(not math.isfinite(value) or value <= 0.0 for value in values):
+                raise ValueError(f"{label} modal frequencies must be finite positive values")
+        if reference and len(reference) > len(masses):
+            raise ValueError("reference_frequencies_hz cannot contain more entries than the number of stories")
+        if observed and len(observed) > len(masses):
+            raise ValueError("observed_frequencies_hz cannot contain more entries than the number of stories")
+        object.__setattr__(self, "story_masses_kg", masses)
+        object.__setattr__(self, "story_stiffness_n_m", stiffnesses)
+        object.__setattr__(self, "reference_frequencies_hz", reference)
+        object.__setattr__(self, "observed_frequencies_hz", observed)
+
+    @property
+    def story_count(self) -> int:
+        return len(self.story_masses_kg)
+
+    @property
+    def natural_frequencies_hz(self) -> tuple[float, ...]:
+        """Return analytical frequencies for the undamped shear model."""
+        n = self.story_count
+        stiffness = np.zeros((n, n), dtype=float)
+        for floor, story_k in enumerate(self.story_stiffness_n_m):
+            stiffness[floor, floor] += story_k
+            if floor > 0:
+                stiffness[floor - 1, floor - 1] += story_k
+                stiffness[floor, floor - 1] -= story_k
+                stiffness[floor - 1, floor] -= story_k
+        inv_sqrt_mass = np.diag(1.0 / np.sqrt(np.asarray(self.story_masses_kg, dtype=float)))
+        mass_normalized = inv_sqrt_mass @ stiffness @ inv_sqrt_mass
+        eigenvalues = np.linalg.eigvalsh(mass_normalized)
+        frequencies = np.sqrt(np.maximum(eigenvalues, 0.0)) / (2.0 * math.pi)
+        return tuple(float(value) for value in frequencies if value > 0.0)
+
+    @property
+    def baseline_frequencies_hz(self) -> tuple[float, ...]:
+        """Explicit reference frequencies, or the model's analytical modes."""
+        return self.reference_frequencies_hz or self.natural_frequencies_hz
+
+    def with_update(
+        self,
+        *,
+        stiffness_scale: float,
+        observed_frequencies_hz: Sequence[float],
+        mode_scale_spread_pct: float,
+        status: str,
+    ) -> "Structure":
+        reference = self.reference_frequencies_hz or self.natural_frequencies_hz
+        return replace(
+            self,
+            story_stiffness_n_m=tuple(k * stiffness_scale for k in self.story_stiffness_n_m),
+            reference_frequencies_hz=reference,
+            observed_frequencies_hz=tuple(float(f) for f in observed_frequencies_hz),
+            update_scale_factor=float(stiffness_scale),
+            update_mode_count=len(observed_frequencies_hz),
+            update_mode_scale_spread_pct=float(mode_scale_spread_pct),
+            update_status=status,
+        )