feat: Remote rendering 3.1e - source per-part state from registry on save and restore it on load

doc/changelog.d/54.added.md

@@ -0,0 +1 @@
+Remote rendering 3.1e - source per-part state from registry on save and restore it on load

src/ansys/visor/viewer/models/common/visor_variable_state.py

@@ -2,7 +2,9 @@
 
 from typing import List, Tuple
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
+
+from ansys.visor.viewer.core.visor_enums import VisorVtkVariableType
 
 
 class VisorVariableState(BaseModel):
@@ -15,11 +17,23 @@ class VisorVariableState(BaseModel):
     a unique identifier for the variable: the variable name, type (POINT/CELL), and number of components, and computes
     the ranges across all datasets/parts that contain that variable.
 
+    ``array_name``, ``type`` and ``num_components`` are those same three identifying properties, carried
+    explicitly (rather than only opaquely inside ``id``) so a consumer can act on them without parsing the
+    client-built identifier.
+
     In the future, the backend can own this, but for now we can treat this as passthrough data,
     as the id value is stable across sessions.
     """
     model_config = ConfigDict(populate_by_name=True)
 
     id: str = Field(...)
+    array_name: str = Field(..., alias="arrayName")
+    type: VisorVtkVariableType = Field(...)
+    num_components: int = Field(..., alias="numComponents")
     magnitude_range: Tuple[float, float] | None = Field(default=None, alias="magnitudeRange")
     ranges: List[Tuple[float, float]] = Field(default_factory=list)
+
+    @field_serializer("type")
+    def _serialize_type(self, value: VisorVtkVariableType) -> str:
+        """Emit the wire value (e.g. "POINT"/"CELL") for both dict-mode and JSON-mode dumps."""
+        return value.value

src/ansys/visor/viewer/models/persist/scene/persisted_scene_state.py

@@ -1,14 +1,61 @@
 """Model for persisted scene state (cross-session)."""
 
-from typing import Dict
+from typing import Any, Dict, Mapping
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from ansys.visor.viewer.models.common.visor_camera_state import VisorCameraState
 from ansys.visor.viewer.models.common.visor_cross_section_state import VisorCrossSectionState
 from ansys.visor.viewer.models.common.visor_variable_state import VisorVariableState
 from ansys.visor.viewer.models.persist.dataset.persisted_dataset_state import PersistedDatasetState
 
+#: Separator used by the client when it mints a variable identifier.  See
+#: ``VisorSpectrumManager.tryAddSpectrumInfo``, which builds the identifier as
+#: ``` `${type}::${name}::${numComponents}` ```.
+_IDENTIFIER_SEPARATOR = "::"
+
+def derive_variable_fields_from_identifier(identifier: Any) -> Dict[str, Any] | None:
+    """Recover ``type``, ``array_name`` and ``num_components`` from a variable identifier.
+
+    This is the inverse of the client's creation of the variable ID, and the only place the
+    identifier is parsed.  The array name is in the middle field and is user data, so it may
+    contain the separator: the split is anchored at both ends rather than left to right, and
+    ``"POINT::stress::yy::3"`` yields the array name ``"stress::yy"``.
+
+    Returns ``None`` when the identifier does not spell out three usable fields, meaning
+    "cannot be derived" rather than "derived to a default".  Callers leave such an
+    entry untouched so ordinary validation reports the missing fields.
+    """
+    if not isinstance(identifier, str):
+        return None
+
+    # Strip out the last field, which is the number of components.
+    # e.g. "POINT::stress::yy::3".rpartition("::") -> ("POINT::stress::yy", "::", "3")
+    head, separator, num_components_str = identifier.rpartition(_IDENTIFIER_SEPARATOR)
+    if not separator:
+        return None
+
+    try:
+        num_components = int(num_components_str)
+    except (TypeError, ValueError):
+        return None
+
+    # Strip out the first field, which is the variable type.  The remainder is the array name,
+    # which may contain the separator.
+    # e.g. "POINT::stress::yy".partition("::") -> ("POINT", "::", "stress::yy")
+    variable_type, separator, array_name = head.partition(_IDENTIFIER_SEPARATOR)
+    if not separator:
+        return None
+
+    if not variable_type or not array_name:
+        return None
+
+    return {
+        "type": variable_type,
+        "array_name": array_name,
+        "num_components": num_components,
+    }
+
 
 class PersistedSceneState(BaseModel):
     """Persisted (cross-session) scene state.
@@ -32,3 +79,56 @@ class PersistedSceneState(BaseModel):
     dataset_states: Dict[str, "PersistedDatasetState"] = Field(default_factory=dict)
     variable_states: Dict[str, "VisorVariableState"] = Field(default_factory=dict)
     model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @field_validator("variable_states", mode="before")
+    @classmethod
+    def _derive_missing_variable_identity_fields(cls, value: Any) -> Any:
+        """Fill absent identity fields on read, from the variable identifier.
+
+        ``array_name``, ``type``, and ``num_components`` are required and stay
+        required: the model is shared with ``RuntimeSceneState.spectrum_states``,
+        so relaxing them would also relax the save-path coercion in
+        ``VisorSaveStateResponse._coerce_app_state``.  Tolerance for older save
+        files lives here, on the container, and applies to the ingest boundary only.
+        """
+        if not isinstance(value, Mapping):
+            return value
+
+        out: Dict[Any, Any] = {}
+        for key, entry in value.items():
+            out[key] = cls._derive_missing_identity_fields_for_entry(key, entry)
+        return out
+
+    @staticmethod
+    def _derive_missing_identity_fields_for_entry(key: Any, entry: Any) -> Any:
+        """Return *entry* with any absent identity fields derived from its identifier."""
+        if isinstance(entry, VisorVariableState) or not isinstance(entry, Mapping):
+            return entry
+
+        # A value that is present but null counts as present and is left
+        # to fail validation.
+        missing = [
+            field
+            for field, alias in (
+                ("array_name", "arrayName"),
+                ("type", "type"),
+                ("num_components", "numComponents"),
+            )
+            if field not in entry and alias not in entry
+        ]
+        if not missing:
+            return entry
+
+        identifier = entry.get("id")
+        if not isinstance(identifier, str) or not identifier:
+            identifier = key
+
+        derived = derive_variable_fields_from_identifier(identifier)
+        if derived is None:
+            return entry
+
+        filled = dict(entry)
+        for field in missing:
+            filled[field] = derived[field]
+        return filled
+