annotations and typing

Author: vld-codra

plotpy/builder/annotation.py

@@ -219,10 +219,10 @@ def annotated_ellipse(
         y0: float,
         x1: float,
         y1: float,
-        x2: float = None,
-        y2: float = None,
-        x3: float = None,
-        y3: float = None,
+        x2: float | None = None,
+        y2: float | None = None,
+        x3: float | None = None,
+        y3: float | None = None,
         title: str | None = None,
         subtitle: str | None = None,
         show_label: bool | None = None,

plotpy/builder/curvemarker.py

@@ -20,7 +20,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Callable
+from typing import TYPE_CHECKING
 
 import numpy  # only to help intersphinx finding numpy doc
 import numpy as np
@@ -45,6 +45,9 @@
     update_style_attr,
 )
 
+if TYPE_CHECKING:
+    from typing import Callable
+
 CURVE_COUNT = 0
 HISTOGRAM_COUNT = 0
 
@@ -228,7 +231,8 @@ def mcurve(self, *args, **kwargs) -> CurveItem | list[CurveItem]:
         Args:
             args: x, y, style
             kwargs: title, color, linestyle, linewidth, marker, markersize,
-            markerfacecolor, markeredgecolor, shade, curvestyle, baseline
+            markerfacecolor, markeredgecolor, shade, curvestyle, baseline,
+            downsampling_factor, use_downsampling
 
         Returns:
             :py:class:`.CurveItem` object

plotpy/config.py

@@ -742,6 +742,7 @@ def make_title(basename, count):
         "marker/cross/pen/width": 1,
         "marker/cross/markerstyle": "Cross",
     },
+    # colormaps options
     "colormaps": {
         "colormaps/default": "colormaps_default.json",
         "colormaps/custom": "colormaps_custom.json",

plotpy/items/annotation.py

@@ -59,7 +59,7 @@ class AnnotatedShape(AbstractShape):
     """
 
     __implements__ = (IBasePlotItem, ISerializableType)
-    SHAPE_CLASS: AbstractShape = RectangleShape  # to be overridden
+    SHAPE_CLASS: type[AbstractShape] = RectangleShape  # to be overridden
     LABEL_ANCHOR: str = ""
 
     def __init__(self, annotationparam: AnnotationParam | None = None) -> None:
@@ -278,7 +278,7 @@ def get_tr_center(self):
     def get_tr_center_str(self):
         """Return center coordinates as a string (with units)"""
         xc, yc = self.get_tr_center()
-        return "( {} ; {} )".format(self.x_to_str(xc), self.y_to_str(yc))
+        return f"( {self.x_to_str(xc)} ; {self.y_to_str(yc)} )"
 
     def get_tr_size(self):
         """Return shape size after applying transform matrix"""
@@ -287,7 +287,7 @@ def get_tr_size(self):
     def get_tr_size_str(self):
         """Return size as a string (with units)"""
         xs, ys = self.get_tr_size()
-        return "{} x {}".format(self.x_to_str(xs), self.y_to_str(ys))
+        return f"{self.x_to_str(xs)} x {self.y_to_str(ys)}"
 
     def get_infos(self) -> str:
         """Get informations on current shape
@@ -601,7 +601,7 @@ def set_rect(self, x1, y1, x2, y2):
         self.shape.set_rect(x1, y1, x2, y2)
         self.set_label_position()
 
-    def get_rect(self):
+    def get_rect(self) -> tuple[float, float, float, float]:
         """
         Return the coordinates of the shape's top-left and bottom-right corners
         """
@@ -659,7 +659,7 @@ def get_tr_angle(self):
         xcoords = self.get_transformed_coords(0, 1)
         _x, yr1 = self.apply_transform_matrix(1.0, 1.0)
         _x, yr2 = self.apply_transform_matrix(1.0, 2.0)
-        return (compute_angle(reverse=yr1 > yr2, *xcoords) + 90) % 180 - 90
+        return (compute_angle(*xcoords, reverse=yr1 > yr2) + 90) % 180 - 90
 
     def get_bounding_rect_coords(self) -> tuple[float, float, float, float]:
         """Return bounding rectangle coordinates (in plot coordinates)
@@ -802,7 +802,7 @@ def get_tr_angle(self):
         xcoords = self.get_transformed_coords(0, 1)
         _x, yr1 = self.apply_transform_matrix(1.0, 1.0)
         _x, yr2 = self.apply_transform_matrix(1.0, 2.0)
-        return (compute_angle(reverse=yr1 > yr2, *xcoords) + 90) % 180 - 90
+        return (compute_angle(*xcoords, reverse=yr1 > yr2) + 90) % 180 - 90
 
     # ----AnnotatedShape API-----------------------------------------------------
     def set_label_position(self):
@@ -834,7 +834,7 @@ def get_infos(self) -> str:
             [
                 _("Center:") + " " + self.get_tr_center_str(),
                 _("Size:") + " " + self.get_tr_size_str(),
-                _("Angle:") + " {:.1f}°".format(self.get_tr_angle()),
+                _("Angle:") + f" {self.get_tr_angle():.1f}°",
             ]
         )
 

plotpy/items/curve/base.py

@@ -358,18 +358,15 @@ def get_data(self) -> tuple[np.ndarray, np.ndarray]:
             tuple: Tuple with two elements: x and y NumPy arrays
         """
         assert isinstance(self._x, np.ndarray) and isinstance(self._y, np.ndarray)
-        # if ignore_decimation:
         return self._x, self._y
-        # return (
-        #     self._x[:: self.param.decimation],
-        #     self._y[:: self.param.decimation],
-        # )
 
     def update_data(self):
+        """Update curve data with current arrays."""
         if isinstance(self._x, np.ndarray) and isinstance(self._y, np.ndarray):
             self._setData(self._x, self._y)
 
     def _setData(self, x: np.ndarray, y: np.ndarray):
+        """Wrapper around QwtPlotCurve.setData() to handle downsampling"""
         if not self.param.use_downsampling or self.param.downsampling_factor == 1:
             return super().setData(x, y)
         return super().setData(
@@ -387,14 +384,6 @@ def set_data(self, x: np.ndarray, y: np.ndarray) -> None:
             this method is called to update decimated data (i.e. only update 1/N value
             with N set in CurveItem.param.decimation).
         """
-        # if (
-        #     isinstance(self._x, np.ndarray)
-        #     and isinstance(self._y, np.ndarray)
-        #     # and decimated_data > 1
-        # ):
-        #     self._x[:: self.param.decimation] = np.array(x, copy=False)
-        #     self._y[:: self.param.decimation] = np.array(y, copy=False)
-        # else:
         self._x = np.array(x, copy=False)
         self._y = np.array(y, copy=False)
         self._setData(self._x, self._y)
@@ -512,9 +501,8 @@ def get_closest_x(self, xc: float) -> tuple[float, float]:
         # We assume X is sorted, otherwise we'd need :
         # argmin(abs(x-xc))
         i = self._x.searchsorted(xc)
-        if i > 0:
-            if np.fabs(self._x[i - 1] - xc) < np.fabs(self._x[i] - xc):
-                return self._x[i - 1], self._y[i - 1]
+        if i > 0 and np.fabs(self._x[i - 1] - xc) < np.fabs(self._x[i] - xc):
+            return self._x[i - 1], self._y[i - 1]
         return self._x[i], self._y[i]
 
     def move_local_point_to(

plotpy/items/image/base.py

@@ -41,12 +41,13 @@
     ITrackableItemType,
     IVoiImageItemType,
 )
+
+# do not import rectangleshape from plotpy.items directly
 from plotpy.items.shape.rectangle import RectangleShape
 from plotpy.lutrange import lut_range_threshold
 from plotpy.mathutils.arrayfuncs import get_nan_range
 from plotpy.mathutils.colormaps import FULLRANGE, get_cmap
 from plotpy.styles.image import RawImageParam
-from plotpy.widgets.colormap_widget import CustomQwtLinearColormap
 
 if TYPE_CHECKING:  # pragma: no cover
     import guidata.dataset.io
@@ -56,8 +57,8 @@
     from qtpy.QtGui import QColor, QPainter
 
     from plotpy.interfaces import IItemType
-    from plotpy.items import RectangleShape
     from plotpy.styles.base import ItemParameters
+    from plotpy.widgets.colormap_widget import CustomQwtLinearColormap
 
 
 class BaseImageItem(QwtPlotItem):
@@ -111,6 +112,7 @@ def __init__(
         self.cmap_table = None
         self.cmap = None
         self.colormap_axis = None
+        self._image: QG.QImage | None = None
 
         self._offscreen = np.array((1, 1), np.uint32)
 
@@ -125,7 +127,6 @@ def __init__(
         self.border_rect.set_style("plot", "shape/imageborder")
         # A, B, Background, Colormap
         self.lut = (1.0, 0.0, None, np.zeros((LUT_SIZE,), np.uint32))
-
         self.set_lut_range((0.0, 255.0))
         self.setItemAttribute(QwtPlotItem.AutoScale)
         self.setItemAttribute(QwtPlotItem.Legend, True)
@@ -467,7 +468,10 @@ def get_color_map(self) -> CustomQwtLinearColormap | None:
         return self.cmap_table
 
     def get_color_map_name(self) -> str | None:
-        """Get colormap name
+        """Get the current colormap name if set. The output value should not directly
+        be used to retrieve a colormap object from one of the global colormap
+        dictionaries, as the colormap name may contain capital letters whereas the
+        colormap string keys of the dictionaries are all lowercase.
 
         Returns:
             Colormap name
@@ -476,6 +480,18 @@ def get_color_map_name(self) -> str | None:
             return None
         return self.cmap_table.name
 
+    def get_color_map_key_name(self) -> str | None:
+        """Same as get_color_map_name, but returns the colormap name in lowercase. This
+        is because the colormap string keys of the global colormap dictionaries are all
+        lowercase.
+
+        Returns:
+            Colormap name
+        """
+        if self.cmap_table is None:
+            return None
+        return self.cmap_table.name.lower()
+
     def set_interpolation(self, interp_mode: int, size: int | None = None) -> None:
         """Set interpolation mode
 
@@ -984,7 +1000,7 @@ def get_histogram(self, nbins: int) -> tuple[np.ndarray, np.ndarray]:
 
     def __process_cross_section(self, ydata, apply_lut):
         if apply_lut:
-            a, b, bg, cmap = self.lut
+            a, b, _bg, _cmap = self.lut
             return (ydata * a + b).clip(0, LUT_MAX)
         else:
             return ydata

plotpy/items/shape/rectangle.py

@@ -50,7 +50,7 @@ def __init__(
         y1: float = 0.0,
         x2: float = 0.0,
         y2: float = 0.0,
-        shapeparam: ShapeParam = None,
+        shapeparam: ShapeParam | None = None,
     ) -> None:
         super().__init__(shapeparam=shapeparam)
         self.set_rect(x1, y1, x2, y2)
@@ -151,7 +151,7 @@ def __init__(
         y2: float = 0.0,
         x3: float = 0.0,
         y3: float = 0.0,
-        shapeparam: ShapeParam = None,
+        shapeparam: ShapeParam | None = None,
     ) -> None:
         super().__init__(shapeparam=shapeparam)
         self.set_rect(x0, y0, x1, y1, x2, y2, x3, y3)

plotpy/mathutils/colormaps.py

@@ -10,7 +10,6 @@
 
 import numpy as np
 import qtpy.QtGui as QG
-import qtpy.QtWidgets as QW
 from guidata.configtools import get_module_data_path
 from qwt import QwtInterval, toQImage
 
@@ -57,7 +56,7 @@ def load_qwt_colormaps_from_json(json_path: str) -> dict[str, CustomQwtLinearCol
         Dictionnary of colormpas names -> CustomQwtLinearColormap
     """
     return {
-        name: CustomQwtLinearColormap.from_iterable(iterable, name=name)
+        name.lower(): CustomQwtLinearColormap.from_iterable(iterable, name=name)
         for name, iterable in load_raw_colormaps_from_json(json_path).items()
     }
 
@@ -95,10 +94,28 @@ def build_icon_from_cmap(
 
 
 def build_icon_from_cmap_name(cmap_name: str) -> QG.QIcon:
-    return build_icon_from_cmap(get_cmap(cmap_name))
+    """Builds an QIcon representing the colormap from the colormap name found in
+    ALL_COLORMAPS global variable.
+
+    Args:
+        cmap_name: colormap name to search in ALL_COLORMAPS
+
+    Returns:
+        QIcon representing the colormap
+    """
+    return build_icon_from_cmap(get_cmap(cmap_name.lower()))
 
 
 def get_cmap(cmap_name: str) -> CustomQwtLinearColormap:
+    """Returns the colormap with the given name from the ALL_COLORMAPS global variable.
+    If the colormap is not found, returns the DEFAULT colormap.
+
+    Args:
+        cmap_name: colormap name to search in ALL_COLORMAPS
+
+    Returns:
+        A CustomQwtLinearColormap instance corresponding to the given name
+    """
     return ALL_COLORMAPS.get(cmap_name, DEFAULT)
 
 
@@ -133,22 +150,18 @@ def get_cmap_path(config_path: str):
     return user_config_path
 
 
+# Load default colormaps path from the config file
 DEFAULT_COLORMAPS_PATH = get_cmap_path(
     CONF.get("colormaps", "colormaps/default", default="colormaps_default.json")  # type: ignore
 )
+# Load custom colormaps path from the config file
 CUSTOM_COLORMAPS_PATH = get_cmap_path(
     CONF.get("colormaps", "colormaps/custom", default="colormaps_custom.json")  # type: ignore
 )
 
+# Load default and custom colormaps from json files
 DEFAULT_COLORMAPS = load_qwt_colormaps_from_json(DEFAULT_COLORMAPS_PATH)
 CUSTOM_COLORMAPS = load_qwt_colormaps_from_json(CUSTOM_COLORMAPS_PATH)
 
+# Merge default and custom colormaps into a single dictionnary to simplify access
 ALL_COLORMAPS = {**DEFAULT_COLORMAPS, **CUSTOM_COLORMAPS}
-
-if __name__ == "__main__":
-    CUSTOM_COLORMAPS["glow_hot"] = CustomQwtLinearColormap.from_iterable(
-        ((0, "#0000ff"), (0.5, "#ff0000"), (1.0, "#ffff00"))
-    )
-    # print(f"Saving custom_colormaps at {CONF.get_path(CUSTOM_COLORMAPS_PATH)}")
-    save_colormaps(CUSTOM_COLORMAPS_PATH, CUSTOM_COLORMAPS)
-    print(CUSTOM_COLORMAPS)

plotpy/plot/base.py

@@ -1585,8 +1585,9 @@ def unselect_item(self, item: itf.IBasePlotItem) -> None:
         item.unselect()
         self.SIG_ITEM_SELECTION_CHANGED.emit(self)
 
-    #TODO: fix return type of the following method (should probably return a QwtPlotItem)
-    def get_last_active_item(self, item_type: type[itf.IItemType]) -> itf.IBasePlotItem | None:
+    def get_last_active_item(
+        self, item_type: type[itf.IItemType]
+    ) -> itf.IBasePlotItem | None:
         """Return last active item corresponding to passed `item_type`
 
         Args:

plotpy/plot/manager.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import weakref
-from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from guidata.qthelpers import create_action
@@ -56,13 +55,15 @@
 )
 
 if TYPE_CHECKING:  # pragma: no cover
+    from typing import Callable
+
     from qwt import QwtPlotCanvas, QwtScaleDiv
 
     from plotpy.panels.base import PanelWidget
     from plotpy.panels.contrastadjustment import ContrastAdjustment
     from plotpy.panels.csection import XCrossSection, YCrossSection
     from plotpy.panels.itemlist import PlotItemList
-    from plotpy.tools.base import GuiTool
+    from plotpy.tools.base import GuiTool, GuiToolT
 
 
 class DefaultPlotID:
@@ -187,7 +188,7 @@ def get_default_toolbar(self) -> QW.QToolBar:
         """
         return self.default_toolbar
 
-    def add_tool(self, ToolKlass: GuiTool, *args, **kwargs) -> GuiTool:
+    def add_tool(self, ToolKlass: type[GuiToolT], *args, **kwargs) -> GuiToolT:
         """
         Register a tool to the manager
             * ToolKlass: tool's class (see :ref:`tools`)
@@ -211,7 +212,7 @@ def add_tool(self, ToolKlass: GuiTool, *args, **kwargs) -> GuiTool:
             self.default_tool = tool
         return tool
 
-    def get_tool(self, ToolKlass: GuiTool) -> GuiTool:
+    def get_tool(self, ToolKlass: type[GuiToolT]) -> GuiToolT | None:
         """Return tool instance from its class
 
         Args:
@@ -497,7 +498,7 @@ def create_action(
         icon: QG.QIcon | None = None,
         tip: str | None = None,
         checkable: bool | None = None,
-        context: QC.Qt.ShortcutContext = QC.Qt.WindowShortcut,
+        context: QC.Qt.ShortcutContext = QC.Qt.ShortcutContext.WindowShortcut,
         enabled: bool | None = None,
     ):
         """