Merge pull request #4258 from t20100/prepare-2.2.2

Release: Prepare 2.2.2

Author: t20100

CHANGELOG.rst

@@ -1,6 +1,17 @@
 Release Notes
 =============
 
+2.2.2: 2025/04/07
+-----------------
+
+* `silx.gui.plot.PlotWidget`:
+
+  * Fixed matplotlib backend issue with plot axes limits (PR #4256)
+  * Fixed OpenGL backend axes (PR #4246)
+
+* `silx.io.h5py_utils`: Fixed support of libhdf5 1.14.x (PR #4242)
+* `silx.opencl`: Fixed context creation through `PYOPENCL_CTX environment` variable (PR #4245)
+
 2.2.1: 2025/02/27
 -----------------
 

src/silx/_version.py

@@ -69,7 +69,7 @@
 
 MAJOR = 2
 MINOR = 2
-MICRO = 1
+MICRO = 2
 RELEV = "final"  # <16
 SERIAL = 0  # <16
 

src/silx/gui/plot/_utils/__init__.py

@@ -86,7 +86,11 @@ def addMarginsToLimits(
                 y2Min = pow(10.0, yMinLog - yMinMargin * yRangeLog)
                 y2Max = pow(10.0, yMaxLog + yMaxMargin * yRangeLog)
 
+    xMin, xMax = checkAxisLimits(xMin, xMax, isXLog)
+    yMin, yMax = checkAxisLimits(yMin, yMax, isYLog)
+
     if y2Min is None or y2Max is None:
         return xMin, xMax, yMin, yMax
     else:
+        y2Min, y2Max = checkAxisLimits(y2Min, y2Max, isYLog)
         return xMin, xMax, yMin, yMax, y2Min, y2Max

src/silx/gui/plot/backends/BackendMatplotlib.py

@@ -1,6 +1,6 @@
 # /*##########################################################################
 #
-# Copyright (c) 2004-2023 European Synchrotron Radiation Facility
+# Copyright (c) 2004-2025 European Synchrotron Radiation Facility
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -552,7 +552,8 @@ def __init__(self, plot, parent=None):
         for axis in (self.ax.yaxis, self.ax.xaxis, self.ax2.yaxis, self.ax2.xaxis):
             axis.set_major_formatter(DefaultTickFormatter())
 
-        self.ax2.set_autoscaley_on(True)
+        self.ax.set_autoscaley_on(False)
+        self.ax2.set_autoscaley_on(False)
 
         # this works but the figure color is left
         if self._matplotlibVersion < Version("2"):
@@ -1192,17 +1193,10 @@ def setLimits(self, xmin, xmax, ymin, ymax, y2min=None, y2max=None):
         self._dirtyLimits = True
         self.ax.set_xlim(min(xmin, xmax), max(xmin, xmax))
 
-        keepRatio = self.isKeepDataAspectRatio()
         if y2min is not None and y2max is not None:
-            if not self.isYAxisInverted():
-                self.ax2.set_ylim(min(y2min, y2max), max(y2min, y2max), auto=keepRatio)
-            else:
-                self.ax2.set_ylim(max(y2min, y2max), min(y2min, y2max), auto=keepRatio)
+            self.ax2.set_ybound(min(y2min, y2max), max(y2min, y2max))
 
-        if not self.isYAxisInverted():
-            self.ax.set_ylim(min(ymin, ymax), max(ymin, ymax), auto=keepRatio)
-        else:
-            self.ax.set_ylim(max(ymin, ymax), min(ymin, ymax), auto=keepRatio)
+        self.ax.set_ybound(min(ymin, ymax), max(ymin, ymax))
 
         self._updateMarkers()
 
@@ -1251,11 +1245,7 @@ def setGraphYLimits(self, ymin, ymax, axis):
             xcenter = 0.5 * (xmin + xmax)
             ax.set_xlim(xcenter - 0.5 * newXRange, xcenter + 0.5 * newXRange)
 
-        keepRatio = self.isKeepDataAspectRatio()
-        if not self.isYAxisInverted():
-            ax.set_ylim(ymin, ymax, auto=keepRatio)
-        else:
-            ax.set_ylim(ymax, ymin, auto=keepRatio)
+        ax.set_ybound(ymin, ymax)
 
         self._updateMarkers()
 
@@ -1317,7 +1307,7 @@ def setYAxisLogarithmic(self, flag):
                     dataRange = self._plot.getDataRange()[dataRangeIndex]
                     if dataRange is None:
                         dataRange = 1, 100  # Fallback
-                    axis.set_ylim(*dataRange, auto=self.isKeepDataAspectRatio())
+                    axis.set_ybound(*dataRange)
                     redraw = True
             if redraw:
                 self.draw()
@@ -1623,6 +1613,8 @@ def resizeEvent(self, event):
             self.ax.get_ybound(),
             self.ax2.get_ybound(),
         )
+        self.ax.set_autoscaley_on(True)
+        self.ax2.set_autoscaley_on(True)
 
         FigureCanvasQTAgg.resizeEvent(self, event)
         if self.isKeepDataAspectRatio() or self._hasOverlays():
@@ -1673,6 +1665,9 @@ def draw(self):
             if xLimits != self.ax.get_xbound() or yLimits != self.ax.get_ybound():
                 self._updateMarkers()
 
+            self.ax.set_autoscaley_on(False)
+            self.ax2.set_autoscaley_on(False)
+
             if xLimits != self.ax.get_xbound():
                 self._plot.getXAxis()._emitLimitsChanged()
             if yLimits != self.ax.get_ybound():

src/silx/gui/plot/backends/BackendOpenGL.py

@@ -1538,21 +1538,16 @@ def _setPlotBounds(self, xRange=None, yRange=None, y2Range=None, keepDim=None):
             self._ensureAspectRatio(keepDim)
 
     def setLimits(self, xmin, xmax, ymin, ymax, y2min=None, y2max=None):
-        assert xmin < xmax
-        assert ymin < ymax
-
         if y2min is None or y2max is None:
             y2Range = None
         else:
-            assert y2min < y2max
             y2Range = y2min, y2max
         self._setPlotBounds((xmin, xmax), (ymin, ymax), y2Range)
 
     def getGraphXLimits(self):
         return self._plotFrame.dataRanges.x
 
     def setGraphXLimits(self, xmin, xmax):
-        assert xmin < xmax
         self._setPlotBounds(xRange=(xmin, xmax), keepDim="x")
 
     def getGraphYLimits(self, axis):
@@ -1563,7 +1558,6 @@ def getGraphYLimits(self, axis):
             return self._plotFrame.dataRanges.y2
 
     def setGraphYLimits(self, ymin, ymax, axis):
-        assert ymin < ymax
         assert axis in ("left", "right")
 
         if axis == "left":

src/silx/io/h5py_utils.py

@@ -1,5 +1,5 @@
 # /*##########################################################################
-# Copyright (C) 2016-2024 European Synchrotron Radiation Facility
+# Copyright (C) 2016-2025 European Synchrotron Radiation Facility
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -173,7 +173,11 @@ def retry_h5py_error(e):
         elif isinstance(e, KeyError):
             # For example this needs to be retried:
             # KeyError: 'Unable to open object (bad object header version number)'
-            return "Unable to open object" in str(e)
+            message = str(e)
+            return (
+                "Unable to open object" in message
+                or "Unable to synchronously open object" in message
+            )
     elif isinstance(e, retry_mod.RetryError):
         return True
     return False

src/silx/io/test/test_h5py_utils.py

@@ -1,5 +1,5 @@
 # /*##########################################################################
-# Copyright (C) 2016-2024 European Synchrotron Radiation Facility
+# Copyright (C) 2016-2025 European Synchrotron Radiation Facility
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -37,6 +37,9 @@
 import multiprocessing
 from contextlib import contextmanager
 
+import h5py
+import pytest
+
 from .. import h5py_utils
 from ...utils.retry import RetryError, RetryTimeoutError
 
@@ -486,3 +489,30 @@ def iter_data(filename, name, start_index=0):
         kw = {"retry_timeout": insufficient_timeout}
         with self.assertRaises(RetryTimeoutError):
             list(iter_data(filename, "/check", **kw))
+
+
+def test_retry_timeout(tmp_path):
+    filepath = tmp_path / "test.h5"
+    with h5py.File(filepath, "w"):
+        pass
+
+    @h5py_utils.retry(retry_timeout=1, retry_period=0.1)
+    def read():
+        with h5py.File(filepath, locking=False) as f:
+            group = f["group"]
+            return group["data"][()]
+
+    with pytest.raises(RetryTimeoutError):
+        read()
+
+    with h5py.File(filepath, "w") as f:
+        f.create_group("group")
+
+    with pytest.raises(RetryTimeoutError):
+        read()
+
+    with h5py.File(filepath, "w") as f:
+        f["group/data"] = 1
+
+    data = read()
+    assert data == 1

src/silx/opencl/common.py

@@ -110,6 +110,43 @@ class mf(object):
 
 AMD_FLOP_PER_CORE = 160  # Measured on a M7820 10 core, 700MHz 1120GFlops
 
+def get_pyopencl_ctx_tuple(pyopencl_ctx_str, cache=None):
+    """
+    Converts a PYOPENCL_CTX environment variable into a tuple (platform, device)
+
+    :param cache: dict with the already created contexts
+    """
+
+    def _convert_to_int(val, default_val=0):
+        try:
+            ret = int(val)
+        except ValueError:
+            ret = default_val
+        return ret
+
+    if pyopencl_ctx_str in ["", ":"]:
+        return (0, 0)
+    if ":" in pyopencl_ctx_str:
+        platform, device = pyopencl_ctx_str.split(":")
+        platform_id = _convert_to_int(platform)
+        device_id = _convert_to_int(device)
+    elif pyopencl_ctx_str.isdigit():
+        platform_id = _convert_to_int(pyopencl_ctx_str)
+        device_id = 0
+    else:
+        if "choose_devices" in dir(pyopencl):
+            device = pyopencl.choose_devices(interactive=False)
+            device_id = device_instance.platform.get_devices().index(device_instance)
+            platform_id = pyopencl.get_platforms().index(device.platform)
+        else:  #Fallback for elder PyOpenCL
+            ctx = pyopencl.create_some_context(interactive=False)
+            device = device_instance = ctx.devices[0]
+            device_id = device_instance.platform.get_devices().index(device_instance)
+            platform_id = pyopencl.get_platforms().index(device.platform)
+            if cache is not None:
+                cache[(platform_id, device_id)] = ctx
+    return (platform_id, device_id)
+
 
 class Device(object):
     """
@@ -603,25 +640,8 @@ def create_context(
             platformid = int(platformid)
             deviceid = int(deviceid)
         elif "PYOPENCL_CTX" in os.environ:
-            ctx = pyopencl.create_some_context()
-            # try:
-            device = ctx.devices[0]
-            platforms = [
-                i
-                for i, p in enumerate(self.platforms)
-                if device.platform.name == p.name
-            ]
-            if platforms:
-                platformid = platforms[0]
-                devices = [
-                    i
-                    for i, d in enumerate(self.platforms[platformid].devices)
-                    if device.name == d.name
-                ]
-                if devices:
-                    deviceid = devices[0]
-                    if cached:
-                        self.context_cache[(platformid, deviceid)] = ctx
+            platformid, deviceid = get_pyopencl_ctx_tuple(os.environ["PYOPENCL_CTX"],
+                                                          cache=self.context_cache if cached else None)
         else:
             ids = self.select_device(type=devicetype, extensions=extensions)
             if ids:
@@ -632,19 +652,11 @@ def create_context(
                 ctx = self.context_cache[(platformid, deviceid)]
             else:
                 try:
-                    ctx = pyopencl.Context(
-                        devices=[
-                            pyopencl.get_platforms()[platformid].get_devices()[deviceid]
-                        ]
-                    )
+                    device = pyopencl.get_platforms()[platformid].get_devices()[deviceid]
+                    ctx = pyopencl.Context(devices=[device])
                 except pyopencl._cl.LogicError as error:
                     self.platforms[platformid].devices[deviceid].set_unavailable()
-                    logger.warning(
-                        "Unable to create context on %s/%s: %s",
-                        platformid,
-                        deviceid,
-                        error,
-                    )
+                    logger.warning(f"Unable to create context for ({platformid}:{deviceid}): {error}")
                     ctx = None
                 else:
                     if cached:

src/silx/opencl/test/test_addition.py

@@ -131,12 +131,8 @@ def test_measurement(self):
         for platform in ocl.platforms:
             for did, device in enumerate(platform.devices):
                 meas = _measure_workgroup_size((platform.id, device.id))
-                self.assertEqual(
-                    meas,
-                    device.max_work_group_size,
-                    "Workgroup size for %s/%s: %s == %s"
-                    % (platform, device, meas, device.max_work_group_size),
-                )
+                self.assertEqual(meas, device.max_work_group_size,
+                    f"Workgroup size for {platform}/{device}: {meas} == {device.max_work_group_size}")
 
     def test_query(self):
         """

src/silx/opencl/test/test_processing.py

@@ -0,0 +1,21 @@
+import os
+import pytest
+
+from silx.opencl.common import ocl
+
+if ocl:
+    from silx.opencl.processing import OpenclProcessing
+
+
+@pytest.mark.skipif(ocl is None, reason="PyOpenCl is missing")
+def test_context_cache():
+
+    op1 = OpenclProcessing()
+    op2 = OpenclProcessing()
+    assert op1.ctx is op2.ctx, "Context should be the same"
+
+    os.environ["PYOPENCL_CTX"] = "0:0"
+    op3 = OpenclProcessing()
+    op4 = OpenclProcessing()
+
+    assert op3.ctx is op4.ctx, "context should be the same"