Merge branch 'develop' into feature/history-panel

# Conflicts:
#	datalab/gui/newobject.py
#	datalab/gui/processor/base.py
#	datalab/gui/processor/signal.py
#	datalab/tests/features/common/interactive_processing_test.py
#	datalab/tests/features/signal/fitdialog_unit_test.py
#	datalab/widgets/fitdialog.py

Author: dappham-CODRA

.github/copilot-instructions.md

@@ -184,6 +184,7 @@ def my_processing_func(src: SignalObj, param: MyParam) -> SignalObj:
     # ... computation logic ...
     return dst
 
+
 # 2. Register in DataLab processor (datalab/gui/processor/signal.py)
 def register_processing(self) -> None:
     self.register_1_to_1(
@@ -308,6 +309,7 @@ generated with `scripts/print_datalab_menus.py`).
 ```python
 from datalab.plugins import PluginBase, PluginInfo
 
+
 class MyPlugin(PluginBase):
     """My custom plugin."""
 
@@ -455,6 +457,7 @@ and remote control from any HTTP client (including WASM/Pyodide environments).
 ```python
 from __future__ import annotations
 
+
 def process_signal(src: SignalObj) -> SignalObj:
     """Process signal."""
     pass
@@ -546,6 +549,7 @@ menu_title = "Processing"  # Not translatable!
 2. **Export from Sigima** (`sigima/proc/signal/__init__.py`):
    ```python
    from sigima.proc.signal.processing import my_feature  # Import
+
    __all__ = [..., "my_feature"]  # Export
    ```
 

.vscode/settings.json

@@ -28,4 +28,11 @@
     "python.testing.pytestPath": "pytest",
     "python.testing.unittestEnabled": false,
     "terminal.integrated.tabs.description": "${workspaceFolder}",
+    "python-envs.pythonProjects": [
+        {
+            "path": ".",
+            "envManager": "ms-python.python:venv",
+            "packageManager": "ms-python.python:pip"
+        }
+    ],
 }

.vscode/tasks.json

@@ -576,7 +576,13 @@
             "label": "🖼️ Refresh doc screenshots",
             "detail": "Maintainer task: regenerate PNG screenshots under doc/images/ by launching DataLab for each language (fr + en). Commit the resulting diff in a dedicated 'docs: refresh screenshots' commit.",
             "type": "shell",
-            "command": "scripts\\update_screenshots.bat",
+            "command": "${command:python.interpreterPath}",
+            "args": [
+                "scripts/run_with_env.py",
+                "cmd",
+                "/c",
+                "scripts\\update_screenshots.bat",
+            ],
             "options": {
                 "cwd": "${workspaceFolder}",
                 "env": {

datalab/gui/creation.py

@@ -4,31 +4,53 @@
 
 from __future__ import annotations
 
+import json
 from typing import TYPE_CHECKING
 
 import guidata.dataset as gds
 import numpy as np
 from sigima.objects import (
+    PEAK_PARAMETERIZATION,
     CustomSignalParam,
     Gauss2DParam,
     ImageDatatypes,
     ImageObj,
     NewImageParam,
     NewSignalParam,
     SignalObj,
+    convert_legacy_peak_creation_params,
     create_signal,
+    validate_peak_creation_params,
 )
 from sigima.objects import create_image_from_param as create_image_headless
 from sigima.objects import create_signal_from_param as create_signal_headless
 from sigima.objects.base import BaseProcParam
-from sigima.objects.signal import DEFAULT_TITLE as SIGNAL_DEFAULT_TITLE
+from sigima.objects.signal import (
+    DEFAULT_TITLE as SIGNAL_DEFAULT_TITLE,
+)
+from sigima.objects.signal import (
+    BaseGaussLorentzVoigtParam,
+)
 
 from datalab.config import _
 
 if TYPE_CHECKING:
     from qtpy import QtWidgets as QW
 
-CREATION_PARAMETERS_OPTION = "creation_param_json"
+CREATION_PARAMETERS_OPTION = "creation_parameters"
+LEGACY_CREATION_PARAMETERS_OPTION = "creation_param_json"
+CREATION_PARAMETERS_FORMAT_VERSION = 1
+
+
+def _decode_dataset_json(dataset_json: str) -> dict[str, object]:
+    """Decode a DataSet JSON payload without instantiating its class."""
+    try:
+        payload = json.loads(dataset_json)
+    except (TypeError, json.JSONDecodeError) as exc:
+        raise ValueError("Invalid creation parameter JSON") from exc
+    if not isinstance(payload, dict):
+        raise ValueError("Creation parameter JSON must contain an object")
+    return payload
 
 
 def insert_creation_parameters(obj: SignalObj | ImageObj, param: gds.DataSet) -> None:
@@ -38,7 +60,17 @@ def insert_creation_parameters(obj: SignalObj | ImageObj, param: gds.DataSet) ->
         obj: Object receiving the serialized parameters.
         param: Creation parameters.
     """
-    obj.set_metadata_option(CREATION_PARAMETERS_OPTION, gds.dataset_to_json(param))
+    dataset_json = gds.dataset_to_json(param)
+    raw_params = _decode_dataset_json(dataset_json)
+    envelope: dict[str, object] = {
+        "format_version": CREATION_PARAMETERS_FORMAT_VERSION,
+        "dataset_json": dataset_json,
+    }
+    if isinstance(param, BaseGaussLorentzVoigtParam):
+        validate_peak_creation_params(raw_params)
+        envelope["peak_parameterization"] = PEAK_PARAMETERIZATION
+    obj.set_metadata_option(CREATION_PARAMETERS_OPTION, envelope)
+    obj.metadata.pop(f"__{LEGACY_CREATION_PARAMETERS_OPTION}", None)
 
 
 def extract_creation_parameters(obj: SignalObj | ImageObj) -> gds.DataSet | None:
@@ -50,11 +82,77 @@ def extract_creation_parameters(obj: SignalObj | ImageObj) -> gds.DataSet | None
     Returns:
         Creation parameters or None if not found.
     """
-    try:
-        param_json = obj.get_metadata_option(CREATION_PARAMETERS_OPTION)
-    except ValueError:
+    options = obj.get_metadata_options()
+    has_current = CREATION_PARAMETERS_OPTION in options
+    has_legacy = LEGACY_CREATION_PARAMETERS_OPTION in options
+    if has_current and has_legacy:
+        raise ValueError("Conflicting creation parameter formats")
+    if not has_current and not has_legacy:
         return None
-    return gds.json_to_dataset(param_json)
+
+    if has_current:
+        envelope = options[CREATION_PARAMETERS_OPTION]
+        if not isinstance(envelope, dict):
+            raise ValueError("Creation parameters must use a versioned envelope")
+        version = envelope.get("format_version")
+        if version != CREATION_PARAMETERS_FORMAT_VERSION:
+            raise ValueError(f"Unsupported creation parameter format: {version!r}")
+        dataset_json = envelope.get("dataset_json")
+        if not isinstance(dataset_json, str):
+            raise ValueError("Creation parameter envelope has no dataset_json")
+        raw_params = _decode_dataset_json(dataset_json)
+        is_peak = raw_params.get("class_name") in {
+            "GaussParam",
+            "LorentzParam",
+            "VoigtParam",
+        }
+        parameterization = envelope.get("peak_parameterization")
+        if is_peak:
+            if parameterization != PEAK_PARAMETERIZATION:
+                raise ValueError(
+                    f"Unsupported peak parameterization: {parameterization!r}"
+                )
+            validate_peak_creation_params(raw_params)
+        elif parameterization is not None:
+            raise ValueError(
+                "Peak parameterization set on non-peak creation parameters"
+            )
+        return gds.json_to_dataset(dataset_json)
+
+    dataset_json = options[LEGACY_CREATION_PARAMETERS_OPTION]
+    if not isinstance(dataset_json, str):
+        raise ValueError("Legacy creation parameters must contain DataSet JSON")
+    raw_params = _decode_dataset_json(dataset_json)
+    if raw_params.get("class_name") in {"GaussParam", "LorentzParam", "VoigtParam"}:
+        validate_peak_creation_params(raw_params)
+    return gds.json_to_dataset(dataset_json)
+
+
+def convert_legacy_creation_parameters(
+    obj: SignalObj | ImageObj,
+) -> gds.DataSet:
+    """Explicitly convert legacy peak creation metadata to version 2.
+
+    The object data is not regenerated; only its reusable creation parameters
+    are converted and stored under the new metadata option.
+
+    Args:
+        obj: Object carrying historical creation metadata.
+
+    Returns:
+        Converted peak creation parameters.
+    """
+    options = obj.get_metadata_options()
+    if CREATION_PARAMETERS_OPTION in options:
+        raise ValueError("Current creation parameters already exist")
+    dataset_json = options.get(LEGACY_CREATION_PARAMETERS_OPTION)
+    if not isinstance(dataset_json, str):
+        raise ValueError("Object has no legacy creation parameters")
+    raw_params = _decode_dataset_json(dataset_json)
+    converted = convert_legacy_peak_creation_params(raw_params)
+    param = gds.json_to_dataset(json.dumps(converted))
+    insert_creation_parameters(obj, param)
+    return param
 
 
 def create_signal_from_param(param: NewSignalParam) -> SignalObj:

datalab/gui/newobject.py

@@ -29,7 +29,10 @@
 
 from datalab.config import _
 from datalab.gui.creation import (
+    CREATION_PARAMETERS_FORMAT_VERSION,
     CREATION_PARAMETERS_OPTION,
+    LEGACY_CREATION_PARAMETERS_OPTION,
+    convert_legacy_creation_parameters,
     create_image_from_param,
     create_signal_from_param,
     extract_creation_parameters,
@@ -39,7 +42,10 @@
 )
 
 __all__ = [
+    "CREATION_PARAMETERS_FORMAT_VERSION",
     "CREATION_PARAMETERS_OPTION",
+    "LEGACY_CREATION_PARAMETERS_OPTION",
+    "convert_legacy_creation_parameters",
     "create_image_gui",
     "create_signal_gui",
     "extract_creation_parameters",