Add macro recovery and recent macros features

Author: PierreRaybaut

datalab/config.py

@@ -436,6 +436,35 @@ def set_def_dict(cls, category: Literal["ima", "sig"], def_dict: dict) -> None:
                     opt.set(def_dict[name])
 
 
+class MacroSection(conf.Section, metaclass=conf.SectionMeta):
+    """Class defining the Macro panel configuration section structure.
+    Each class attribute is an option (metaclass is automatically affecting
+    option names in .INI file based on class attribute names)."""
+
+    # UUIDs of the macros whose tab was open when DataLab was last closed
+    # (JSON-serialized list of strings).
+    open_tab_uids = conf.Option()
+
+    # UUID of the macro tab that was active when DataLab was last closed.
+    active_tab_uid = conf.Option()
+
+    # Serialized state of the editor/console QSplitter (base64-encoded
+    # QByteArray, see QSplitter.saveState).
+    splitter_state = conf.Option()
+
+    # Maximum number of lines kept in the macro console (FIFO).
+    console_max_lines = conf.Option()
+
+    # If True, closing a macro tab only hides it; the macro stays in the
+    # workspace. The user must use "Delete macro" to remove it permanently.
+    close_tab_keeps_macro = conf.Option()
+
+    # Path to a user-managed directory containing custom macro templates
+    # (``*.py`` files). Each file may declare its description on the first
+    # line using the ``# DataLab template: ...`` tag.
+    templates_path = conf.Option()
+
+
 class AISection(conf.Section, metaclass=conf.SectionMeta):
     """Class defining the AI assistant configuration section structure.
     Each class attribute is an option (metaclass is automatically affecting
@@ -487,6 +516,7 @@ class Conf(conf.Configuration, metaclass=conf.ConfMeta):
     view = ViewSection()
     proc = ProcSection()
     io = IOSection()
+    macro = MacroSection()
     ai = AISection()
 
 
@@ -536,6 +566,10 @@ def initialize():
     iofmts = Conf.io.imageio_formats.get(())
     if len(iofmts) > 0:
         sigima_options.imageio_formats.set(iofmts)  # Sync with sigima config
+    # Macro section
+    Conf.macro.console_max_lines.get(5000)
+    Conf.macro.close_tab_keeps_macro.get(True)
+    Conf.macro.templates_path.get(Conf.get_path("macro_templates"))
     # Proc section
     Conf.proc.operation_mode.get("single")
     Conf.proc.use_signal_bounds.get(False)

datalab/data/icons/libre-gui-action-delete.svg

@@ -17,6 +17,7 @@
 import re
 import sys
 import time
+import uuid
 
 from guidata.io import BaseIOHandler
 from guidata.utils.misc import to_string
@@ -29,9 +30,13 @@
 from datalab.config import _
 from datalab.env import execenv
 from datalab.gui import ObjItf
+from datalab.utils import macrorecovery
 
 UNTITLED_NB = 0
 
+# Debounce delay before persisting a modified macro to the recovery cache.
+_AUTOSAVE_DELAY_MS = 500
+
 
 class MacroMeta(type(QC.QObject), abc.ABCMeta):
     """Mixed metaclass to avoid conflicts"""
@@ -88,10 +93,15 @@ def __init__(self, console: PythonShellWidget, title: str | None = None) -> None
         super().__init__()
         self.console = console
         self.title = self.get_untitled_title() if title is None else title
+        self.uid = uuid.uuid4().hex
         self.editor = CodeEditor(language="python")
         self.editor.setLineWrapMode(QW.QPlainTextEdit.NoWrap)
         self.set_code(self.MACRO_SAMPLE)
         self.editor.modificationChanged.connect(self.modification_changed)
+        self._autosave_timer = QC.QTimer(self)
+        self._autosave_timer.setSingleShot(True)
+        self._autosave_timer.setInterval(_AUTOSAVE_DELAY_MS)
+        self._autosave_timer.timeout.connect(self._autosave_pending)
         self.process = None
         self.__last_exit_code = None
 
@@ -128,6 +138,8 @@ def serialize(self, writer: BaseIOHandler) -> None:
             writer.write(self.title)
         with writer.group("contents"):
             writer.write(self.get_code())
+        with writer.group("uid"):
+            writer.write(self.uid)
 
     def deserialize(self, reader: BaseIOHandler) -> None:
         """Deserialize this macro
@@ -139,6 +151,15 @@ def deserialize(self, reader: BaseIOHandler) -> None:
             self.title = reader.read_any()
         with reader.group("contents"):
             self.set_code(reader.read_any())
+        # Backward-compat: ``uid`` was added in v1.4; fall back to a fresh
+        # UUID when reading older workspaces.
+        try:
+            with reader.group("uid"):
+                stored_uid = reader.read_any()
+            if stored_uid:
+                self.uid = stored_uid
+        except Exception:  # pylint: disable=broad-except
+            pass
 
     def to_file(self, filename: str) -> None:
         """Save macro to file
@@ -209,6 +230,29 @@ def modification_changed(self, state: bool) -> None:
         """
         if state:
             self.MODIFIED.emit()
+            self._autosave_timer.start()
+
+    def _autosave_pending(self) -> None:
+        """Persist the current code to the recovery cache (best-effort)."""
+        try:
+            macrorecovery.save_pending(self.uid, self.title, self.get_code())
+        except OSError:
+            pass
+
+    def flush_autosave(self) -> None:
+        """Force an immediate write to the recovery cache (if pending)."""
+        if self._autosave_timer.isActive():
+            self._autosave_timer.stop()
+        self._autosave_pending()
+
+    def clear_autosave(self) -> None:
+        """Remove this macro from the recovery cache."""
+        if self._autosave_timer.isActive():
+            self._autosave_timer.stop()
+        try:
+            macrorecovery.clear_pending(self.uid)
+        except OSError:
+            pass
 
     @staticmethod
     def transcode(bytearr: QC.QByteArray) -> str:
@@ -271,6 +315,7 @@ def print(self, text, error=False, eol_before=True) -> None:
 
     def run(self) -> None:
         """Run macro"""
+        self.flush_autosave()
         self.process = QC.QProcess()
         code = self.get_code()
         datalab_path = osp.abspath(osp.join(osp.dirname(datalab.__file__), os.pardir))

datalab/gui/macroeditor.py

@@ -0,0 +1,143 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+DataLab Macro templates
+=======================
+
+This package bundles ready-to-use macro examples that are surfaced in the
+"New macro" dropdown of the Macro panel. Each template is a single ``.py``
+file whose first comment line is parsed as the template description::
+
+    # DataLab template: Short human-readable description
+
+The rest of the file is loaded verbatim as the macro source code.
+
+User-defined templates
+----------------------
+
+Additional templates can be dropped into the user templates directory
+(by default ``<USER_CONFIG_DIR>/macro_templates`` — typically
+``~/.DataLab/macro_templates`` on Linux/macOS and
+``%APPDATA%\\.DataLab\\macro_templates`` on Windows). The location can be
+overridden through ``Conf.macro.templates_path``.
+
+Any ``*.py`` file placed in that directory is exposed in the "New macro"
+dropdown after the bundled templates. Filenames starting with an
+underscore are ignored.
+"""
+
+from __future__ import annotations
+
+import os
+import os.path as osp
+import pkgutil
+from dataclasses import dataclass
+
+_TEMPLATE_FILES = (
+    "simple_macro.py",
+    "imageproc_macro.py",
+    "call_method_macro.py",
+)
+
+_DESCRIPTION_TAG = "# DataLab template:"
+
+
+@dataclass(frozen=True)
+class MacroTemplate:
+    """A bundled macro template.
+
+    Attributes:
+        name: Stable identifier (file stem, e.g. ``"simple_macro"``).
+        title: Suggested macro title (used as the tab name).
+        description: One-line description shown in the menu tooltip.
+        code: Python source code (without the description tag line).
+    """
+
+    name: str
+    title: str
+    description: str
+    code: str
+
+
+def _parse(name: str, raw: str) -> MacroTemplate:
+    """Parse a raw template file content into a MacroTemplate."""
+    lines = raw.splitlines()
+    description = ""
+    if lines and lines[0].startswith(_DESCRIPTION_TAG):
+        description = lines[0][len(_DESCRIPTION_TAG) :].strip()
+        lines = lines[1:]
+        # Strip leading blank lines after the tag
+        while lines and not lines[0].strip():
+            lines = lines[1:]
+    title = description or name.replace("_", " ").title()
+    code = "\n".join(lines).rstrip() + "\n"
+    return MacroTemplate(name=name, title=title, description=description, code=code)
+
+
+def _user_templates_dir() -> str | None:
+    """Return the user templates directory path, or None if disabled."""
+    # Imported lazily to avoid a circular import at module load time.
+    try:
+        from datalab.config import Conf
+    except ImportError:
+        return None
+    try:
+        return Conf.macro.templates_path.get(None)
+    except Exception:  # pragma: no cover - defensive
+        return None
+
+
+def _load_user_templates() -> list[MacroTemplate]:
+    """Load user-defined templates from the configured directory."""
+    directory = _user_templates_dir()
+    if not directory or not osp.isdir(directory):
+        return []
+    templates: list[MacroTemplate] = []
+    seen: set[str] = set()
+    try:
+        filenames = sorted(os.listdir(directory))
+    except OSError:
+        return []
+    for filename in filenames:
+        if not filename.endswith(".py") or filename.startswith("_"):
+            continue
+        name = osp.splitext(filename)[0]
+        if name in seen:
+            continue
+        seen.add(name)
+        path = osp.join(directory, filename)
+        try:
+            with open(path, encoding="utf-8") as fdesc:
+                raw = fdesc.read()
+        except OSError:
+            continue
+        templates.append(_parse(name, raw))
+    return templates
+
+
+def list_templates() -> list[MacroTemplate]:
+    """Return all macro templates (bundled first, then user-defined)."""
+    templates: list[MacroTemplate] = []
+    bundled_names: set[str] = set()
+    for filename in _TEMPLATE_FILES:
+        data = pkgutil.get_data(__name__, filename)
+        if data is None:
+            continue
+        raw = data.decode("utf-8")
+        name = osp.splitext(filename)[0]
+        bundled_names.add(name)
+        templates.append(_parse(name, raw))
+    for template in _load_user_templates():
+        if template.name in bundled_names:
+            # Bundled templates take precedence; skip user file with same stem
+            continue
+        templates.append(template)
+    return templates
+
+
+def get_template(name: str) -> MacroTemplate | None:
+    """Return a template by its stable name (file stem)."""
+    for template in list_templates():
+        if template.name == name:
+            return template
+    return None

datalab/gui/macros_templates/__init__.py

@@ -0,0 +1,14 @@
+# DataLab template: Call panel methods
+
+from datalab.control.proxy import RemoteProxy
+
+proxy = RemoteProxy()
+
+# List currently visible signals and images via generic method calls.
+sigs = proxy.call_method("get_object_titles", panel="signal")
+imgs = proxy.call_method("get_object_titles", panel="image")
+print(f"Signals: {len(sigs)} | Images: {len(imgs)}")
+
+# Switch panels through the proxy.
+proxy.set_current_panel("signal")
+print(f"Current panel: {proxy.get_current_panel()}")

datalab/gui/macros_templates/call_method_macro.py

@@ -0,0 +1,22 @@
+# DataLab template: Image processing example
+
+import numpy as np
+
+from datalab.control.proxy import RemoteProxy
+
+proxy = RemoteProxy()
+
+# Generate a noisy 2D Gaussian.
+size = 256
+y, x = np.mgrid[0:size, 0:size]
+cx, cy = size / 2, size / 2
+img = np.exp(-((x - cx) ** 2 + (y - cy) ** 2) / (2 * 30**2))
+img += 0.05 * np.random.rand(size, size)
+
+proxy.add_image("gaussian", img)
+print("Created image 'gaussian'")
+proxy.set_current_panel("image")
+
+# Apply an FFT to the newly created image.
+proxy.calc("fft")
+print("FFT computed")