PythonQwt 0.16.1__tar.gz → 0.16.2__tar.gz

{pythonqwt-0.16.1/PythonQwt.egg-info → pythonqwt-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.16.1
+Version: 0.16.2
 Summary: Qt plotting widgets for Python
 Author-email: Pierre Raybaut <pierre.raybaut@gmail.com>
 License: PythonQwt License Agreement

{pythonqwt-0.16.1 → pythonqwt-0.16.2/PythonQwt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.16.1
+Version: 0.16.2
 Summary: Qt plotting widgets for Python
 Author-email: Pierre Raybaut <pierre.raybaut@gmail.com>
 License: PythonQwt License Agreement

{pythonqwt-0.16.1 → pythonqwt-0.16.2}/PythonQwt.egg-info/SOURCES.txt

@@ -95,6 +95,7 @@ qwt/tests/test_errorbar.py
 qwt/tests/test_eventfilter.py
 qwt/tests/test_highdpi.py
 qwt/tests/test_image.py
+qwt/tests/test_issue107_gdi_leak.py
 qwt/tests/test_loadtest.py
 qwt/tests/test_logcurve.py
 qwt/tests/test_mapdemo.py

{pythonqwt-0.16.1 → pythonqwt-0.16.2}/qwt/__init__.py

@@ -63,7 +63,7 @@ from qwt.symbol import QwtSymbol as QSbl  # see deprecated section
 from qwt.text import QwtText  # noqa: F401
 from qwt.toqimage import array_to_qimage as toQImage  # noqa: F401
 
-__version__ = "0.16.1"
+__version__ = "0.16.2"
 QWT_VERSION_STR = "6.1.5"
 
 

{pythonqwt-0.16.1 → pythonqwt-0.16.2}/qwt/plot.py

@@ -20,6 +20,7 @@ QwtPlotItem
 """
 
 import math
+import weakref
 
 import numpy as np
 from qtpy.QtCore import QEvent, QObject, QRectF, QSize, Qt, Signal
@@ -1007,7 +1008,12 @@ class QwtPlot(QFrame):
         return QFrame.event(self, event)
 
     def eventFilter(self, obj, event):
-        if obj is self.__data.canvas:
+        try:
+            canvas = self.__data.canvas
+        except AttributeError:
+            # The plot is being destroyed: Python attributes already cleared
+            return QFrame.eventFilter(self, obj, event)
+        if obj is canvas:
             if event.type() == QEvent.Resize:
                 self.updateCanvasMargins()
             elif event.type() == 178:  # QEvent.ContentsRectChange:
@@ -1195,7 +1201,12 @@ class QwtPlot(QFrame):
         """
         :return: Return a minimum size hint
         """
-        hint = self.__data.layout.minimumSizeHint(self)
+        try:
+            layout = self.__data.layout
+        except AttributeError:
+            # The plot is being destroyed: Python attributes already cleared
+            return QSize()
+        hint = layout.minimumSizeHint(self)
         hint += QSize(2 * self.frameWidth(), 2 * self.frameWidth())
         return hint
 
@@ -1815,16 +1826,23 @@ class QwtPlotItem(object):
 
             :py:meth:`detach()`
         """
-        if plot is self.__data.plot:
+        if plot is self.plot():
             return
 
-        if self.__data.plot:
-            self.__data.plot.attachItem(self, False)
+        current = self.plot()
+        if current is not None:
+            current.attachItem(self, False)
 
-        self.__data.plot = plot
+        # Store the parent plot as a WEAK reference: an item must not keep its
+        # plot (and the plot's GDI-backed child widgets) alive. A strong
+        # back-reference here forms a ``plot <-> item`` reference cycle that can
+        # only be reclaimed by the cyclic garbage collector, which delays the
+        # release of native GDI handles and can lead to GDI-handle exhaustion
+        # on Windows when many plots are created and destroyed.
+        self.__data.plot = None if plot is None else weakref.ref(plot)
 
-        if self.__data.plot:
-            self.__data.plot.attachItem(self, True)
+        if plot is not None:
+            plot.attachItem(self, True)
 
     def detach(self):
         """
@@ -1854,7 +1872,8 @@ class QwtPlotItem(object):
         """
         :return: attached plot
         """
-        return self.__data.plot
+        ref = self.__data.plot
+        return None if ref is None else ref()
 
     def z(self):
         """
@@ -1881,11 +1900,12 @@ class QwtPlotItem(object):
             :py:meth:`z()`, :py:meth:`QwtPlotDict.itemList()`
         """
         if self.__data.z != z:
-            if self.__data.plot:
-                self.__data.plot.attachItem(self, False)
+            plot = self.plot()
+            if plot is not None:
+                plot.attachItem(self, False)
             self.__data.z = z
-            if self.__data.plot:
-                self.__data.plot.attachItem(self, True)
+            if plot is not None:
+                plot.attachItem(self, True)
             self.itemChanged()
 
     def setTitle(self, title):
@@ -2091,8 +2111,9 @@ class QwtPlotItem(object):
 
             :py:meth:`QwtPlot.legendChanged()`, :py:meth:`QwtPlot.autoRefresh()`
         """
-        if self.__data.plot:
-            self.__data.plot.autoRefresh()
+        plot = self.plot()
+        if plot is not None:
+            plot.autoRefresh()
 
     def legendChanged(self):
         """
@@ -2102,8 +2123,9 @@ class QwtPlotItem(object):
 
             :py:meth:`QwtPlot.updateLegend()`, :py:meth:`itemChanged()`
         """
-        if self.testItemAttribute(QwtPlotItem.Legend) and self.__data.plot:
-            self.__data.plot.updateLegend(self)
+        plot = self.plot()
+        if self.testItemAttribute(QwtPlotItem.Legend) and plot is not None:
+            plot.updateLegend(self)
 
     def setAxes(self, xAxis, yAxis):
         """

{pythonqwt-0.16.1 → pythonqwt-0.16.2}/qwt/plot_canvas.py

@@ -13,6 +13,7 @@ QwtPlotCanvas
    :members:
 """
 
+import weakref
 from collections.abc import Sequence
 
 from qtpy.QtCore import QEvent, QObject, QPoint, QPointF, QRect, QRectF, QSize, Qt
@@ -442,7 +443,12 @@ class QwtPlotCanvas(QFrame):
 
     def __init__(self, plot=None):
         super(QwtPlotCanvas, self).__init__(plot)
-        self.__plot = plot
+        # Store the parent plot as a WEAK reference to avoid a
+        # ``plot <-> canvas`` reference cycle (the plot already owns the canvas
+        # through Qt's parent/child relationship). A strong back-reference here
+        # would keep the plot alive until the cyclic garbage collector runs,
+        # delaying the release of native GDI handles on Windows.
+        self.__plot = None if plot is None else weakref.ref(plot)
         self.setFrameStyle(QFrame.Panel | QFrame.Sunken)
         self.setLineWidth(2)
         self.__data = QwtPlotCanvas_PrivateData()
@@ -456,7 +462,8 @@ class QwtPlotCanvas(QFrame):
         """
         :return: Parent plot widget
         """
-        return self.__plot
+        ref = self.__plot
+        return None if ref is None else ref()
 
     def setPaintAttribute(self, attribute, on=True):
         """
@@ -695,7 +702,9 @@ class QwtPlotCanvas(QFrame):
             else:
                 #                print('**DEBUG: QwtPlotCanvas.drawCanvas')
                 painter.setClipRect(self.contentsRect(), Qt.IntersectClip)
-        self.plot().drawCanvas(painter)
+        plot = self.plot()
+        if plot is not None:
+            plot.drawCanvas(painter)
         painter.restore()
         if withBackground and hackStyledBackground:
             #  Now paint the border on top

pythonqwt-0.16.2/qwt/tests/test_issue107_gdi_leak.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the Qwt License
+# (see LICENSE file for more details)
+
+"""
+Test for issue 107: GDI handle exhaustion on Windows.
+"""
+
+import numpy as np
+import pytest
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+
+from qwt import QwtPlot, QwtPlotCurve
+from qwt.tests.utils import TestEnvironment
+
+
+def run_stress_cycle():
+    """Run one cycle of plot creation, rendering and destruction."""
+    plot = QwtPlot()
+    plot.resize(QC.QSize(800, 600))
+    plot.show()
+
+    # Create many curves with different fonts (via titles) to pressure caches
+    for i in range(20):
+        curve = QwtPlotCurve(f"Curve {i}")
+        x = np.linspace(0, 10, 100)
+        y = np.sin(x + i / 10.0)
+        curve.setData(x, y)
+        curve.attach(plot)
+
+    plot.replot()
+    QW.QApplication.processEvents()
+
+    plot.close()
+    plot.deleteLater()
+    QW.QApplication.processEvents()
+
+
+def test_gdi_leak_stability():
+    """
+    Repeatedly create/render/destroy plots to check for GDI leak stability.
+    On Windows, without the fix, this would crash after a certain number of cycles
+    due to GDI handle exhaustion.
+    """
+    env = TestEnvironment()
+    if not env.unattended:
+        pytest.skip("This test is for CI/unattended mode only")
+
+    # Close any top-level widgets left alive by previous tests in the shared
+    # QApplication. This test aggressively drives ``deleteLater()`` +
+    # ``processEvents()`` in-process; processing deferred deletions while stale
+    # widgets from earlier tests are still pending triggers a Qt teardown
+    # fast-fail (0xC0000409) on Windows. Starting from a clean widget set makes
+    # the test robust inside the full suite (it already passes in isolation).
+    app = QW.QApplication.instance() or QW.QApplication([])
+    for widget in list(app.topLevelWidgets()):
+        widget.close()
+        widget.deleteLater()
+    app.processEvents()
+    app.sendPostedEvents(None, QC.QEvent.DeferredDelete)
+    app.processEvents()
+
+    n_cycles = 50
+    for i in range(n_cycles):
+        run_stress_cycle()
+
+
+if __name__ == "__main__":
+    app = QW.QApplication.instance() or QW.QApplication([])
+    test_gdi_leak_stability()

{pythonqwt-0.16.1 → pythonqwt-0.16.2}/qwt/text.py

@@ -46,6 +46,7 @@ QwtRichTextEngine
 import math
 import os
 import struct
+from collections import OrderedDict
 
 from qtpy.QtCore import QObject, QRectF, QSize, QSizeF, Qt
 from qtpy.QtGui import (
@@ -208,67 +209,50 @@ class QwtTextEngine(object):
         pass
 
 
-ASCENTCACHE = {}
+ASCENTCACHE = OrderedDict()
 
-# Module-level cache: ``id(font) -> tuple_key`` (fast path) and
-# ``tuple_key -> tuple_key`` (slow path). The tuple key is built from a
-# handful of QFont attributes that uniquely identify the *logical* font for
-# metrics purposes. Tick-rendering uses very few distinct fonts in practice
-# so both dicts stay tiny.
-#
-# This replaces the previous ``id(font) -> font.key()`` design. Two reasons:
+_FM_CACHE_LIMIT = 256  # max QFontMetrics / QFontMetricsF / ascent entries
+
+
+# Single-slot, leak-free memo for ``QFont.key()``.
 #
-# 1. ``QFont.key()`` is a sip dispatch that costs ~3.3 us/call on PyQt5 and
-#    ~9.3 us/call on PyQt6 -- it became the single biggest residual hotspot
-#    in ``QwtText.textSize`` on PyQt6.
-# 2. PyQt6 returns a fresh Python wrapper around the same QFont on most
-#    calls, so ``id(font)`` changes between calls and the id-keyed fast path
-#    misses ~92% of the time. The tuple-key second level recovers the hits
-#    those misses would have produced, without paying for ``font.key()``.
+# ``QFont.key()`` is the only correct, binding-stable identity for metrics
+# caching, but it is a relatively costly sip call (~1 us on PyQt5, ~1.6 us on
+# PyQt6) and it is queried once per tick label. The previous implementation
+# memoized it in an ``id(font) -> (font, key)`` dict which kept a *strong
+# reference* to every distinct QFont wrapper it saw (up to 1024). That is a
+# genuine memory / GDI-handle leak that the bounded ``.clear()`` only masked
+# (see the issue #93 segfault regression).
 #
-# The tuple key uses ``(family, pixelSize-or-pointSizeF, weight, italic,
-# stretch, styleStrategy)``. This is what determines ``QFontMetrics`` output
-# in practice; if two QFonts share these values they share metrics.
-
-_FONT_KEY_CACHE: dict = {}  # id(font) -> tuple_key (fast path)
-_FONT_TUPLE_CACHE: dict = {}  # tuple_key -> tuple_key (interning, also acts
-#                              as the "have we seen this logical font" set)
-_FONT_KEY_CACHE_LIMIT = 1024
-_FM_CACHE_LIMIT = 256  # max QFontMetrics/QFontMetricsF entries per engine
-
-
-def _font_tuple_key(font):
-    """Build a hashable tuple identifying the logical font."""
-    px = font.pixelSize()
-    return (
-        font.family(),
-        px if px > 0 else font.pointSizeF(),
-        font.weight(),
-        font.italic(),
-        font.stretch(),
-        font.styleStrategy(),
-    )
+# This single-slot memo keeps at most ONE QFont alive (bounded => not a leak)
+# while still skipping the repeated ``font.key()`` call for the very common
+# case of the same painter font being reused across an entire scale-draw pass.
+# Retaining that one font is precisely what makes the ``id()`` comparison safe
+# against id reuse. On a miss the real ``font.key()`` is recomputed, so the
+# result is always lossless and correct.
+_LAST_FONT = None
+_LAST_FONT_ID = None
+_LAST_FONT_KEY = None
 
 
 def font_key_cached(font):
-    """Return a hashable cache key uniquely identifying ``font`` for metrics.
+    """Return ``font.key()`` using a single-slot, leak-free memo.
+
+    The returned value is the genuine ``QFont.key()`` string and is safe to use
+    as a dict key for metrics caches. At most one ``QFont`` is ever retained.
 
-    The returned value is **not** ``QFont.key()`` -- it is a tuple computed
-    from a handful of QFont attributes. It is safe to use as a dict key for
-    metrics caches (callers in this module always compare by ``==`` only).
+    :param QFont font: Font
+    :return: ``font.key()``
     """
+    global _LAST_FONT, _LAST_FONT_ID, _LAST_FONT_KEY
     fid = id(font)
-    entry = _FONT_KEY_CACHE.get(fid)
-    if entry is not None:
-        return entry[1]
-    tkey = _font_tuple_key(font)
-    # Intern: reuse the same tuple object across all id() variants so dict
-    # lookups in caller-side caches benefit from object-identity hash hits.
-    interned = _FONT_TUPLE_CACHE.setdefault(tkey, tkey)
-    if len(_FONT_KEY_CACHE) >= _FONT_KEY_CACHE_LIMIT:
-        _FONT_KEY_CACHE.clear()
-    _FONT_KEY_CACHE[fid] = (font, interned)
-    return interned
+    if fid == _LAST_FONT_ID:
+        return _LAST_FONT_KEY
+    key = font.key()
+    _LAST_FONT = font
+    _LAST_FONT_ID = fid
+    _LAST_FONT_KEY = key
+    return key
 
 
 def get_screen_resolution():
@@ -305,13 +289,9 @@ class QwtPlainTextEngine(QwtTextEngine):
 
     def __init__(self):
         self.qrectf_max = QRectF(0, 0, QWIDGETSIZE_MAX, QWIDGETSIZE_MAX)
-        self._fm_cache = {}
-        self._fm_cache_f = {}
-        self._margins_cache = {}
-        # Fast path: when textMargins is called repeatedly with the same
-        # QFont instance, skip the (expensive) font.key() Qt call.
-        self._margins_last_id = -1
-        self._margins_last_value = None
+        self._fm_cache = OrderedDict()
+        self._fm_cache_f = OrderedDict()
+        self._margins_cache = OrderedDict()
 
     def fontmetrics(self, font):
         fid = font_key_cached(font)
@@ -319,8 +299,10 @@ class QwtPlainTextEngine(QwtTextEngine):
             return self._fm_cache[fid]
         except KeyError:
             if len(self._fm_cache) >= _FM_CACHE_LIMIT:
-                self._fm_cache.clear()
-            return self._fm_cache.setdefault(fid, QFontMetrics(font))
+                self._fm_cache.popitem(last=False)
+            fm = QFontMetrics(font)
+            self._fm_cache[fid] = fm
+            return fm
 
     def fontmetrics_f(self, font):
         fid = font_key_cached(font)
@@ -328,8 +310,10 @@ class QwtPlainTextEngine(QwtTextEngine):
             return self._fm_cache_f[fid]
         except KeyError:
             if len(self._fm_cache_f) >= _FM_CACHE_LIMIT:
-                self._fm_cache_f.clear()
-            return self._fm_cache_f.setdefault(fid, QFontMetricsF(font))
+                self._fm_cache_f.popitem(last=False)
+            fm = QFontMetricsF(font)
+            self._fm_cache_f[fid] = fm
+            return fm
 
     def heightForWidth(self, font, flags, text, width):
         """
@@ -359,14 +343,15 @@ class QwtPlainTextEngine(QwtTextEngine):
         return rect.size()
 
     def effectiveAscent(self, font):
-        global ASCENTCACHE
         fontKey = font_key_cached(font)
         ascent = ASCENTCACHE.get(fontKey)
         if ascent is not None:
             return ascent
         if len(ASCENTCACHE) >= _FM_CACHE_LIMIT:
-            ASCENTCACHE.clear()
-        return ASCENTCACHE.setdefault(fontKey, self.findAscent(font))
+            ASCENTCACHE.popitem(last=False)
+        ascent = self.findAscent(font)
+        ASCENTCACHE[fontKey] = ascent
+        return ascent
 
     def findAscent(self, font):
         dummy = "E"
@@ -409,20 +394,14 @@ class QwtPlainTextEngine(QwtTextEngine):
         :param QFont font: Font of the text
         :return: tuple (left, right, top, bottom) representing margins
         """
-        # Fast path: same QFont object as the previous call.
-        font_id = id(font)
-        if font_id == self._margins_last_id:
-            return self._margins_last_value
         fkey = font_key_cached(font)
         cached = self._margins_cache.get(fkey)
         if cached is None:
             fm = self.fontmetrics(font)
             cached = (0, 0, fm.ascent() - self.effectiveAscent(font), fm.descent())
             if len(self._margins_cache) >= _FM_CACHE_LIMIT:
-                self._margins_cache.clear()
+                self._margins_cache.popitem(last=False)
             self._margins_cache[fkey] = cached
-        self._margins_last_id = font_id
-        self._margins_last_value = cached
         return cached
 
     def draw(self, painter, rect, flags, text):
@@ -588,12 +567,20 @@ class QwtText_LayoutCache(object):
     def __init__(self):
         self.textSize = None
         self.fontKey = None
+        # ``id(font)`` fast path for ``QwtText.textSize``. ``font`` keeps a
+        # strong reference to the cached font so its id cannot be reused by a
+        # different object while cached (guards against a stale-size false hit).
+        # This is a per-instance, single-slot cache: it retains at most one
+        # QFont per QwtText and is released with the QwtText, so unlike the old
+        # unbounded module-level font cache it cannot leak.
         self.fontId = -1
+        self.font = None
 
     def invalidate(self):
         self.textSize = None
         self.fontKey = None
         self.fontId = -1
+        self.font = None
 
 
 class QwtText(object):
@@ -1108,6 +1095,10 @@ class QwtText(object):
         """
         font = self.usedFont(defaultFont)
         cache = self.__layoutCache
+        # Fast path: same font *object* as the previous call on this text.
+        # ``cache.font`` keeps that font alive, so the id comparison is safe
+        # against id reuse, and we skip the (relatively costly) ``font.key()``
+        # call performed by ``font_key_cached``.
         font_id = id(font)
         if cache.textSize is not None and cache.fontId == font_id:
             sz = QSizeF(cache.textSize)
@@ -1123,6 +1114,7 @@ class QwtText(object):
                 )
                 cache.fontKey = fkey
             cache.fontId = font_id
+            cache.font = font
             sz = QSizeF(cache.textSize)
         if self.__data.layoutAttributes & self.MinimumLayout:
             (left, right, top, bottom) = self.__data.textEngine.textMargins(font)