Refactor computation method calls to use calc instead of compute_* for consistency across the codebase

Author: PierreRaybaut

datalab/baseproxy.py

@@ -25,7 +25,6 @@
 from __future__ import annotations
 
 import abc
-from collections.abc import Callable
 from contextlib import contextmanager
 from typing import TYPE_CHECKING, Generator
 
@@ -148,9 +147,9 @@ def context_no_refresh(self) -> Generator[None, None, None]:
 
             >>> with proxy.context_no_refresh():
             ...     proxy.add_image("image1", data1)
-            ...     proxy.compute_fft()
-            ...     proxy.compute_wiener()
-            ...     proxy.compute_ifft()
+            ...     proxy.calc("fft")
+            ...     proxy.calc("wiener")
+            ...     proxy.calc("ifft")
             ...     # Auto refresh is disabled during the above operations
         """
         self.toggle_auto_refresh(False)
@@ -495,44 +494,23 @@ def import_macro_from_file(self, filename: str) -> None:
 
     @abc.abstractmethod
     def calc(self, name: str, param: gds.DataSet | None = None) -> gds.DataSet:
-        """Call compute function ``name`` in current panel's processor.
+        """Call computation feature ``name``
 
-        Args:
-            name: Compute function name
-            param: Compute function parameter. Defaults to None.
-
-        Raises:
-            ValueError: unknown function
-        """
+        .. note::
 
-    def __getattr__(self, name: str) -> Callable:
-        """Return compute function ``name`` in current panel's processor.
+            This calls either the processor's ``compute_<name>`` method (if it exists),
+            or the processor's ``<name>`` computation feature (if it is registered,
+            using the ``run_feature`` method).
+            It looks for the function in all panels, starting with the current one.
 
         Args:
             name: Compute function name
-
-        Returns:
-            Callable: Compute function
+            param: Compute function parameter. Defaults to None.
 
         Raises:
-            AttributeError: If compute function ``name`` does not exist
+            ValueError: unknown function
         """
 
-        def compute_func(param: gds.DataSet | None = None) -> gds.DataSet:
-            """Compute function.
-
-            Args:
-                param: Compute function parameter. Defaults to None.
-
-            Returns:
-                Compute function result
-            """
-            return self.calc(name, param)
-
-        if name.startswith("compute_"):
-            return compute_func
-        raise AttributeError(f"DataLab has no compute function '{name}'")
-
 
 class BaseProxy(AbstractDLControl, metaclass=abc.ABCMeta):
     """Common base class for DataLab proxies

datalab/gui/macroeditor.py

@@ -79,7 +79,7 @@ class Macro(QC.QObject, ObjItf, metaclass=MacroMeta):
 
 z = np.random.rand(20, 20)
 proxy.add_image("toto", z)
-proxy.compute_fft()
+proxy.calc("fft")
 
 print("All done!")
 """

datalab/gui/main.py

@@ -1181,7 +1181,14 @@ def set_current_panel(self, panel: str) -> None:
 
     @remote_controlled
     def calc(self, name: str, param: gds.DataSet | None = None) -> None:
-        """Call compute function ``name`` in current panel's processor.
+        """Call computation feature ``name``
+
+        .. note::
+
+            This calls either the processor's ``compute_<name>`` method (if it exists),
+            or the processor's ``<name>`` computation feature (if it is registered,
+            using the ``run_feature`` method).
+            It looks for the function in all panels, starting with the current one.
 
         Args:
             name: Compute function name
@@ -1190,26 +1197,30 @@ def calc(self, name: str, param: gds.DataSet | None = None) -> None:
         Raises:
             ValueError: unknown function
         """
-        name = name.removeprefix("compute_")
         panels = [self.tabwidget.currentWidget()]
         panels.extend(self.panels)
         for panel in panels:
             if isinstance(panel, base.BaseDataPanel):
                 panel: base.BaseDataPanel
-                try:
-                    feature = panel.processor.get_feature(name)
-                    panel.processor.run_feature(feature, param)
+                # Some computation features are wrapped in a method with a
+                # "compute_" prefix, so we check for this first:
+                func = getattr(panel.processor, f"compute_{name}", None)
+                if func is not None:
+                    if param is None:
+                        func()
+                    else:
+                        func(param)
                     return
-                except ValueError:
-                    for funcname in (name, f"compute_{name}"):
-                        func = getattr(panel.processor, funcname, None)
-                        if func is not None:
-                            if param is None:
-                                func()
-                            else:
-                                func(param)
-                            return
-        raise ValueError(f"Unknown function {name}")
+                else:
+                    # If the function is not wrapped, we check if it is a
+                    # registered feature:
+                    try:
+                        feature = panel.processor.get_feature(name)
+                        panel.processor.run_feature(feature, param)
+                        return
+                    except ValueError:
+                        continue
+        raise ValueError(f"Unknown computation function {name}")
 
     # ------GUI refresh
     def has_objects(self) -> bool:

datalab/proxy.py

@@ -7,9 +7,6 @@
 The :mod:`datalab.proxy` module provides a way to access DataLab features from a proxy
 class.
 
-The list of compute methods accessible from the proxy objects is available in the
-:ref:`processor_methods` section.
-
 Remote proxy
 ^^^^^^^^^^^^
 
@@ -62,25 +59,17 @@
 - :class:`datalab.gui.processor.signal.SignalProcessor`
 - :class:`datalab.gui.processor.image.ImageProcessor`
 
-.. seealso::
-
-    The list of processor methods is available in tables below.
-
-There are two ways to call a processor method:
-
-1. Using the :meth:`calc` method of the proxy object:
+To run a computation feature associated to a processor, you can use the
+:meth:`calc` method of the proxy object:
 
 .. code-block:: python
 
     # Call a method without parameter
-    proxy.calc("compute_average")
-
-    # This is equivalent to:
     proxy.calc("average")
 
     # Call a method with parameters
     p = sigima.params.MovingAverageParam.create(n=30)
-    proxy.calc("compute_moving_average", p)
+    proxy.calc("moving_average", p)
 
 2. Directly calling the processor method from the proxy object:
 
@@ -305,7 +294,14 @@ def add_object(
         self._datalab.add_object(obj, group_id, set_current)
 
     def calc(self, name: str, param: gds.DataSet | None = None) -> None:
-        """Call compute function ``name`` in current panel's processor.
+        """Call computation feature ``name``
+
+        .. note::
+
+            This calls either the processor's ``compute_<name>`` method (if it exists),
+            or the processor's ``<name>`` computation feature (if it is registered,
+            using the ``run_feature`` method).
+            It looks for the function in all panels, starting with the current one.
 
         Args:
             name: Compute function name

datalab/remote.py

@@ -528,7 +528,14 @@ def delete_metadata(
 
     @remote_call
     def calc(self, name: str, param_data: list[str] | None = None) -> bool:
-        """Call compute function ``name`` in current panel's processor.
+        """Call computation feature ``name``
+
+        .. note::
+
+            This calls either the processor's ``compute_<name>`` method (if it exists),
+            or the processor's ``<name>`` computation feature (if it is registered,
+            using the ``run_feature`` method).
+            It looks for the function in all panels, starting with the current one.
 
         Args:
             name: Compute function name
@@ -975,7 +982,14 @@ def add_object(
         self._datalab.add_object(obj_data, group_id, set_current)
 
     def calc(self, name: str, param: gds.DataSet | None = None) -> None:
-        """Call compute function ``name`` in current panel's processor.
+        """Call computation feature ``name``
+
+        .. note::
+
+            This calls either the processor's ``compute_<name>`` method (if it exists),
+            or the processor's ``<name>`` computation feature (if it is registered,
+            using the ``run_feature`` method).
+            It looks for the function in all panels, starting with the current one.
 
         Args:
             name: Compute function name

datalab/tests/backbone/main_app_test.py

@@ -99,9 +99,9 @@ def test_main_app():
 
         # Use "calc" method with parameters
         param = sigima.params.MovingMedianParam.create(n=5)
-        win.calc("compute_moving_median", param)
+        win.calc("moving_median", param)
         # Use "calc" method without parameters
-        win.calc("compute_integral")
+        win.calc("integral")
         # Use "calc" and choose an unknown computation method
         try:
             win.calc("unknown_method")

datalab/tests/features/control/remoteclient_unit.py

@@ -53,7 +53,7 @@ def multiple_commands(remote: RemoteProxy):
         remote.calc("log10")
 
         param = XYCalibrateParam.create(a=1.2, b=0.1)
-        remote.calc("compute_calibration", param)
+        remote.calc("calibration", param)
 
         time.sleep(2)  # Avoid permission error when trying to clean-up temporary files
 

datalab/tests/features/macro/macroeditor_unit_test.py

@@ -42,7 +42,7 @@ def get_macro_example_path() -> str:
 
 z = np.random.rand(20, 20)
 proxy.add_image("toto", z)
-proxy.compute_fft()
+proxy.calc("fft")
 
 print("All done! :)")
 """

doc/intro/tutorials/fabry_perot.rst

@@ -223,8 +223,8 @@ To extract the intensity profile along the X axis, we have two options:
 
 Let's try the first option, by selecting the "Line profile..." entry |profile|:
 that is the most straightforward way to extract a profile from an image, and it
-corresponds to the ``compute_profile`` method of DataLab's API (so it can be used
-in a script, a plugin or a macro).
+corresponds to the ``calc("line_profile")`` computation feature of DataLab's API
+(so it can be used in a script, a plugin or a macro).
 
 .. figure:: ../../images/tutorials/fabry_perot/24.png
 

doc/locale/fr/LC_MESSAGES/intro/tutorials/fabry_perot.po

@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: DataLab \n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-03-20 16:09+0100\n"
+"POT-Creation-Date: 2025-07-08 15:38+0200\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: fr\n"
@@ -190,8 +190,8 @@ msgstr "Soit activer l'outil \"Profil rectiligne\" |cross_section| dans la barre
 msgid "cross_section"
 msgstr ""
 
-msgid "Let's try the first option, by selecting the \"Line profile...\" entry |profile|: that is the most straightforward way to extract a profile from an image, and it corresponds to the ``compute_profile`` method of DataLab's API (so it can be used in a script, a plugin or a macro)."
-msgstr "Essayons la première option, en sélectionnant l'entrée \"Extraire le profil...\" |profile| : c'est la façon la plus simple d'extraire un profil d'une image, et cela correspond à la méthode ``compute_profile`` de l'API de DataLab (donc elle peut être utilisée dans un script, un plugin ou une macro)."
+msgid "Let's try the first option, by selecting the \"Line profile...\" entry |profile|: that is the most straightforward way to extract a profile from an image, and it corresponds to the ``calc(\"line_profile\")`` computation feature of DataLab's API (so it can be used in a script, a plugin or a macro)."
+msgstr "Essayons la première option, en sélectionnant l'entrée \"Profil rectiligne...\" |profile| : c'est la façon la plus simple d'extraire un profil d'une image, et cela correspond à la méthode ``calc(\"line_profile\")`` de l'API de DataLab (donc elle peut être utilisée dans un script, un plugin ou une macro)."
 
 msgid "Select the \"Line profile...\" entry |profile| in the \"Operations\" menu."
 msgstr "Sélectionnez l'entrée \"Profil rectiligne...\" |profile| dans le menu \"Opérations\"."