PythonQwt 0.15.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

{pythonqwt-0.15.0.dist-info → pythonqwt-0.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.15.0
+Version: 0.16.0
 Summary: Qt plotting widgets for Python
 Author-email: Pierre Raybaut <pierre.raybaut@gmail.com>
 License: PythonQwt License Agreement
@@ -666,12 +666,11 @@ License: PythonQwt License Agreement
 Project-URL: Homepage, https://github.com/PlotPyStack/PythonQwt/
 Project-URL: Documentation, https://PythonQwt.readthedocs.io/en/latest/
 Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Software Development :: Widget Sets
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
-Classifier: Topic :: Scientific/Engineering
-Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
 Classifier: Topic :: Software Development :: User Interfaces
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: Microsoft :: Windows
@@ -683,15 +682,18 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: <4,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: NumPy>=1.19
+Requires-Dist: NumPy>=1.21
 Requires-Dist: QtPy>=1.9
 Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pylint; extra == "dev"
 Requires-Dist: Coverage; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
 Provides-Extra: doc
 Requires-Dist: PyQt5; extra == "doc"
 Requires-Dist: sphinx>6; extra == "doc"
@@ -760,7 +762,7 @@ tests.run()
 or from the command line:
 
 ```bash
-PythonQwt
+PythonQwt-tests
 ```
 
 Tests may also be executed in unattended mode:
@@ -773,9 +775,9 @@ PythonQwt-tests --mode unattended
 
 The `qwt` package is a pure Python implementation of `Qwt` C++ library with the following limitations.
 
-The following `Qwt` classes won't be reimplemented in `qwt` because more powerful features already exist in `guiqwt`: `QwtPlotZoomer`, `QwtCounter`, `QwtEventPattern`, `QwtPicker`, `QwtPlotPicker`.
+The following `Qwt` classes won't be reimplemented in `qwt` because more powerful features already exist in `PlotPy`: `QwtPlotZoomer`, `QwtCounter`, `QwtEventPattern`, `QwtPicker`, `QwtPlotPicker`.
 
-Only the following plot items are currently implemented in `qwt` (the only plot items needed by `guiqwt`): `QwtPlotItem` (base class), `QwtPlotItem`, `QwtPlotMarker`, `QwtPlotSeriesItem` and `QwtPlotCurve`.
+Only the following plot items are currently implemented in `qwt` (the only plot items needed by `PlotPy`): `QwtPlotItem` (base class), `QwtPlotGrid`, `QwtPlotMarker`, `QwtPlotSeriesItem` and `QwtPlotCurve`.
 
 See "Overview" section in [documentation](https://pythonqwt.readthedocs.io/en/latest/) for more details on API limitations when comparing to Qwt.
 
@@ -798,14 +800,14 @@ Compatibility table:
 
 | PythonQwt version | PyQt5 | PyQt6 | PySide2 | PySide6 |
 |-------------------|-------|-------|---------|---------|
-| 0.16 and earlier  | ✅    | ⚠️    | ❌     | ⚠️      |
+| 0.15 and earlier  | ✅    | ⚠️    | ❌     | ⚠️      |
 | Latest            | ✅    | ✅    | ❌     | ✅      |
 
 ### Requirements
 
 - Python >=3.9
-- QtPy >= 1.3 (and a Python-to-Qt binding library, see above)
-- NumPy >= 1.5
+- QtPy >= 1.9 (and a Python-to-Qt binding library, see above)
+- NumPy >= 1.21
 
 ### Optional dependencies
 
@@ -814,12 +816,22 @@ Compatibility table:
 
 ### Installation
 
+From PyPI:
+
+```bash
+pip install PythonQwt
+```
+
 From the source package:
 
 ```bash
 python -m build
 ```
 
+## Performance investigation
+
+Tooling for performance benchmarks, profiling and visual-regression checks across PyQt5/PyQt6/PySide6 lives in [`scripts/`](scripts/README.md). See [`doc/issue93_optimization_summary.md`](doc/issue93_optimization_summary.md) for a worked example.
+
 ## Copyrights
 
 ### Main code base

{pythonqwt-0.15.0.dist-info → pythonqwt-0.16.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
-pythonqwt-0.15.0.dist-info/licenses/LICENSE,sha256=qjEk8TRuXmFS7QC-omINvD1UPGqWaOs6CzcCZoMEhdI,33457
-qwt/__init__.py,sha256=IYGoZiDuvezTXga1nUybeNvDi9I-ntKYbQc0qwRIFpc,5993
+pythonqwt-0.16.0.dist-info/licenses/LICENSE,sha256=qjEk8TRuXmFS7QC-omINvD1UPGqWaOs6CzcCZoMEhdI,33457
+qwt/__init__.py,sha256=wOp2xyXj0loXQntSFHwu_OzVj09zvQ6n-BLp46BXy68,5990
 qwt/_math.py,sha256=fNcPJcaK-ldCCFB20T2N58LEkQ1lwZY1-q5veXXhwl8,1501
 qwt/color_map.py,sha256=fLRpymqOXtLrhuPrbbCxTvNINbr2GH7pYBG4fZidrcs,11812
 qwt/column_symbol.py,sha256=0aFyQ05ryTKbaSTctkhtXa0pB_tWG444zlH3991_bt0,5760
 qwt/dyngrid_layout.py,sha256=wgff6mZ1okNhQRRbwaw1I__vOXqGdUG0uafkShuns08,13477
-qwt/graphic.py,sha256=lISwinyParPXoJCL8D_9x9Q0JyJVeykrTWSm1Ubluzo,28177
+qwt/graphic.py,sha256=rSxvgIAm9ctcyszvZrN_03KpBhKSHabbPYdcrztSta8,28962
 qwt/interval.py,sha256=PMrCQxV9NXGk2JG0MNjJ3zGTNTSSRfa_noxbpm-Okns,12287
 qwt/legend.py,sha256=GBUim67HWgwLat5tOWDpK98fWcFxV-RkxWjoyWd9Gao,31313
-qwt/null_paintdevice.py,sha256=AAVyQCVgZKyIw7i-J9ElB0_-8KRV9OXDr140TwMxLSs,9144
+qwt/null_paintdevice.py,sha256=1pgbcvyRTVN32RGzuPzUOm0iUImjvPQ4l5OfJVyA3hg,9375
 qwt/painter.py,sha256=k345puF4MAoTye0WBveiTNpCNWXx1K2o62_I0PZYlIA,16536
-qwt/painter_command.py,sha256=b_uZb56YlzYFG3ZmB5ykjkBQQAadQD8epknsQSEai54,6957
+qwt/painter_command.py,sha256=7D3goNsX_2Ufr5kCpC3Cr1t8GoD5Yz0G1oIZJKvoGBY,8501
 qwt/plot.py,sha256=d8rf4F-fpQgdpTTqNKQFJh7B0FlQ4WlquooeJQRn_eo,75660
-qwt/plot_canvas.py,sha256=PiIRrdZsK1YcV5cQkIpz6H5H6A-dTr2HUJ5MHvDHDG0,30312
+qwt/plot_canvas.py,sha256=INRcxB17dvyGI7Jqi2FX4gm16EG4gzJKULj9inHkibA,30309
 qwt/plot_curve.py,sha256=ThlfxUjB4yiP_Dh96P7PXusyqUfDWcRcyt31OHvu2vk,37059
 qwt/plot_directpainter.py,sha256=JCWNhCC21L1A1HZnxd-C95QNlrVJbLztmGab-X8gCGc,10165
 qwt/plot_grid.py,sha256=h-cDTzibEzQyX2g25SBg5ysyXwmONmMFy9NcuzFySYc,16607
@@ -20,20 +20,20 @@ qwt/plot_marker.py,sha256=6vDHdMsyGClMruWLA4lChUCpoLzmxGNkvmICm0KjP6I,21284
 qwt/plot_renderer.py,sha256=v-fSwicMGQBa_kQx4hJJptlVNpNsKbgWk9jjqG-r_1g,27201
 qwt/plot_series.py,sha256=Wa_Wunu-t_L8vl95RJq6__k-XA8UV2YNIsc8yNGpTT8,10654
 qwt/qthelpers.py,sha256=GpvLr96Ip8SIGwyFfs0f7ocHyKPB7PEjHBQyrpw84xw,1405
-qwt/scale_div.py,sha256=2Ay5mgduXgSm4OrDMcaEWIzenAiBuEASZRoX99PWEE4,9276
-qwt/scale_draw.py,sha256=P9WGlfcldgpaHRq6hsrRgnFgtYP7JgTgybVCMbZLFic,38564
-qwt/scale_engine.py,sha256=yEjcSBWbpdUKCqXBxJccsyz2ZFcR278_QxfgX_fVVCY,36365
-qwt/scale_map.py,sha256=WobkNna6_RPXYZjGK7gZLykNxN_kYnrcB6fEaWgnL2w,9182
+qwt/scale_div.py,sha256=_iI5cy4s8H6wigE8xsn7W44T2-DqVADqdjQ31uJPa_I,9266
+qwt/scale_draw.py,sha256=iO39q7nXJRuFTYan3m5taAGqvmzCq2JX0PhySWtAYVo,41007
+qwt/scale_engine.py,sha256=7KQB5k-JXuJMsEMQXBJBNppCN-rTN97UKQCYXdazvqQ,36674
+qwt/scale_map.py,sha256=rHmPv7e9voEFuAIInQJq60mTtIGrLMViNlgJYu20znA,9605
 qwt/scale_widget.py,sha256=p202DrRgMraGbVcubzkatvVXOLbO9CPho729hz6gqa0,27125
 qwt/symbol.py,sha256=DIXtIOgniO70pScKF-H_mee8GgBuycW3YcsopvfCRGY,39147
-qwt/text.py,sha256=vLegaksF4ZqnWIf_HidMbVRgu-eXPX8CwM1ykyNt6OE,42467
+qwt/text.py,sha256=isLS7UmbJrAmOoxhszPwrkJSRTh5WFmqVkbz_npIi94,48099
 qwt/toqimage.py,sha256=H2u_qDt32n7HGZakWvs3Ve0G3u04Uk2ZQYp8MuZkkmU,1723
 qwt/transform.py,sha256=bFkdmI2wDjOJrUZU6E9-sAvwoo_umXycxq6LPvD6N_c,6078
 qwt/tests/__init__.py,sha256=diBkA_H_Xuxb84tNelsNU4djTlUnKJ5HZNZr02EwnjE,1102
 qwt/tests/comparative_benchmarks.py,sha256=hlLFkyWzadbUyUX2vka_l2bdcGe8U9sOKBDny3o3U40,1821
 qwt/tests/conftest.py,sha256=LwqVA58_Cv7Fitpcn9bGdhbWDBwID_3gaZg2LkJQtGQ,2196
 qwt/tests/test_backingstore.py,sha256=AIiRPqcNPY1riXSQXU43tqB2_z02PhxmK1zA4OxQixM,524
-qwt/tests/test_bodedemo.py,sha256=bOIApjBQA1J4aZkVBnzByiKqhqEcmQpag1TvIfsuHMs,9386
+qwt/tests/test_bodedemo.py,sha256=A9iZ4FmTmn96YAwxeIQIPBwIZtj4Jk_ftB78bJAIV_c,9367
 qwt/tests/test_cartesian.py,sha256=0VCrvclqbQJSEGhWpZLq6brA9Qm9oRIgluEBbxOTOds,3855
 qwt/tests/test_cpudemo.py,sha256=1XECvuJwOzMjI5JWCBUwvnQ6dCkcDEqZlhQ7KU8N-Rs,12853
 qwt/tests/test_curvebenchmark1.py,sha256=a53CvA149Ng1Vj4oruKo4Gp952-0A5gLXvRPOiNSYQk,5891
@@ -49,7 +49,7 @@ qwt/tests/test_loadtest.py,sha256=ZTHatcGAbLyvS0BpbOWbzPD2Bjz4rckF7oxZsUVQ5KM,18
 qwt/tests/test_logcurve.py,sha256=XOtR0asSqFfzc0VL0qfXN0fXNvxvLnz5fxmNZ2gzQWk,1129
 qwt/tests/test_mapdemo.py,sha256=e7rvB8IPKYVVii8UgdHSbOHLc3i7eB21EQNKZ151Kc8,3423
 qwt/tests/test_multidemo.py,sha256=YS-P08qcakD41OJy6ZI53ofKOnUvD-2_uum0yOLiIRc,2530
-qwt/tests/test_relativemargin.py,sha256=E2PqK4e8Ml-NZGuhslBlCsIPEcFm08nLwsn0jZT_h70,2093
+qwt/tests/test_relativemargin.py,sha256=Shn0aE7UeETSSaQFpt4DrMOFeMN3p4rmEHKqPhXfQTI,2097
 qwt/tests/test_simple.py,sha256=4opQp_-RkcVdpRyYSh89ddBkeXCPrppB-_2KTiu5vjI,2347
 qwt/tests/test_stylesheet.py,sha256=cuL1iY4pp5ZoMX4OI86amJA6R5SzQsH1JUWLtEiitZ4,950
 qwt/tests/test_symbols.py,sha256=YcGM0_Em8QtcbqpLSU98PxvGo7BIIYviP2o_4Fg2LbI,5607
@@ -77,8 +77,8 @@ qwt/tests/data/symbol.svg,sha256=ONkkohVqpg3OO2-XEZge7UZLqqNyOQXbSpLgHXcTBFU,127
 qwt/tests/data/symbols.png,sha256=wiqRBc2MJluJ-am9LtZ0K9DHV9BnreYMiEvfzJUFzCk,55586
 qwt/tests/data/testlauncher.png,sha256=WmucObp30QYYKsVRBs5-6t1aEN0FbIWRmOVFN1gt-vQ,139676
 qwt/tests/data/vertical.png,sha256=EvyG6q6rZm6pTT08Y_nzdBYCnqmoX1QDuEQtp2pyGlw,34076
-pythonqwt-0.15.0.dist-info/METADATA,sha256=QWFqtT14JgbY-aEXt3CoS8Jj0iKN0ZNSpdC8wE4GgZE,45097
-pythonqwt-0.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pythonqwt-0.15.0.dist-info/entry_points.txt,sha256=pdPda-YcYigCi00hR4tMxWKu6byxM2x3zA8BQFDYvwI,46
-pythonqwt-0.15.0.dist-info/top_level.txt,sha256=KB1IBdWRWnaItyJMaECwZiEi1jWt3IvqCrRVVhMjTu8,4
-pythonqwt-0.15.0.dist-info/RECORD,,
+pythonqwt-0.16.0.dist-info/METADATA,sha256=jjr2ZDxH0abEGbmHoFLQsXEbk8X-3FLRTRqajqSnqDk,45515
+pythonqwt-0.16.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pythonqwt-0.16.0.dist-info/entry_points.txt,sha256=pdPda-YcYigCi00hR4tMxWKu6byxM2x3zA8BQFDYvwI,46
+pythonqwt-0.16.0.dist-info/top_level.txt,sha256=KB1IBdWRWnaItyJMaECwZiEi1jWt3IvqCrRVVhMjTu8,4
+pythonqwt-0.16.0.dist-info/RECORD,,

{pythonqwt-0.15.0.dist-info → pythonqwt-0.16.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (82.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

qwt/__init__.py

@@ -22,8 +22,8 @@ External resources:
     * Project page on GitHub: `GitHubPage`_
     * Bug reports and feature requests: `GitHub`_
 
-.. _PyPI: https://pypi.python.org/pypi/PythonQwt
-.. _GitHubPage: http://pierreraybaut.github.io/PythonQwt
+.. _PyPI: https://pypi.org/project/PythonQwt/
+.. _GitHubPage: https://github.com/PlotPyStack/PythonQwt
 .. _GitHub: https://github.com/PlotPyStack/PythonQwt
 """
 
@@ -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.15.0"
+__version__ = "0.16.0"
 QWT_VERSION_STR = "6.1.5"
 
 

qwt/graphic.py

@@ -26,7 +26,23 @@ from qtpy.QtGui import (
 )
 
 from qwt.null_paintdevice import QwtNullPaintDevice
-from qwt.painter_command import QwtPainterCommand
+from qwt.painter_command import QwtPainterCommand, _flag_int
+
+# See painter_command.py for the rationale: cache the QPaintEngine.DirtyXxx
+# flags as plain ints so the State-replay branch below does plain int bitwise
+# tests instead of going through Python's enum.Flag.__and__ on PyQt6.
+_DIRTY_PEN = _flag_int(QPaintEngine.DirtyPen)
+_DIRTY_BRUSH = _flag_int(QPaintEngine.DirtyBrush)
+_DIRTY_BRUSH_ORIGIN = _flag_int(QPaintEngine.DirtyBrushOrigin)
+_DIRTY_FONT = _flag_int(QPaintEngine.DirtyFont)
+_DIRTY_BACKGROUND = _flag_int(QPaintEngine.DirtyBackground)
+_DIRTY_TRANSFORM = _flag_int(QPaintEngine.DirtyTransform)
+_DIRTY_CLIP_ENABLED = _flag_int(QPaintEngine.DirtyClipEnabled)
+_DIRTY_CLIP_REGION = _flag_int(QPaintEngine.DirtyClipRegion)
+_DIRTY_CLIP_PATH = _flag_int(QPaintEngine.DirtyClipPath)
+_DIRTY_HINTS = _flag_int(QPaintEngine.DirtyHints)
+_DIRTY_COMPOSITION_MODE = _flag_int(QPaintEngine.DirtyCompositionMode)
+_DIRTY_OPACITY = _flag_int(QPaintEngine.DirtyOpacity)
 
 
 def qwtHasScalablePen(painter):
@@ -83,35 +99,36 @@ def qwtExecCommand(painter, cmd, renderHints, transform, initialTransform):
         painter.drawImage(data.rect, data.image, data.subRect, data.flags)
     elif cmd.type() == QwtPainterCommand.State:
         data = cmd.stateData()
-        if data.flags & QPaintEngine.DirtyPen:
+        flags = _flag_int(data.flags)
+        if flags & _DIRTY_PEN:
             painter.setPen(data.pen)
-        if data.flags & QPaintEngine.DirtyBrush:
+        if flags & _DIRTY_BRUSH:
             painter.setBrush(data.brush)
-        if data.flags & QPaintEngine.DirtyBrushOrigin:
+        if flags & _DIRTY_BRUSH_ORIGIN:
             painter.setBrushOrigin(data.brushOrigin)
-        if data.flags & QPaintEngine.DirtyFont:
+        if flags & _DIRTY_FONT:
             painter.setFont(data.font)
-        if data.flags & QPaintEngine.DirtyBackground:
+        if flags & _DIRTY_BACKGROUND:
             painter.setBackgroundMode(data.backgroundMode)
             painter.setBackground(data.backgroundBrush)
-        if data.flags & QPaintEngine.DirtyTransform:
+        if flags & _DIRTY_TRANSFORM:
             painter.setTransform(data.transform)
-        if data.flags & QPaintEngine.DirtyClipEnabled:
+        if flags & _DIRTY_CLIP_ENABLED:
             painter.setClipping(data.isClipEnabled)
-        if data.flags & QPaintEngine.DirtyClipRegion:
+        if flags & _DIRTY_CLIP_REGION:
             painter.setClipRegion(data.clipRegion, data.clipOperation)
-        if data.flags & QPaintEngine.DirtyClipPath:
+        if flags & _DIRTY_CLIP_PATH:
             painter.setClipPath(data.clipPath, data.clipOperation)
-        if data.flags & QPaintEngine.DirtyHints:
+        if flags & _DIRTY_HINTS:
             for hint in (
                 QPainter.Antialiasing,
                 QPainter.TextAntialiasing,
                 QPainter.SmoothPixmapTransform,
             ):
                 painter.setRenderHint(hint, bool(data.renderHints & hint))
-        if data.flags & QPaintEngine.DirtyCompositionMode:
+        if flags & _DIRTY_COMPOSITION_MODE:
             painter.setCompositionMode(data.compositionMode)
-        if data.flags & QPaintEngine.DirtyOpacity:
+        if flags & _DIRTY_OPACITY:
             painter.setOpacity(data.opacity)
 
 

qwt/null_paintdevice.py

@@ -272,8 +272,12 @@ class QwtNullPaintDevice(QPaintDevice):
                 * 25.4
                 / self.metric(QPaintDevice.PdmDpiY)
             )
+        elif deviceMetric == QPaintDevice.PdmDevicePixelRatio:
+            value = 1
+        elif deviceMetric == QPaintDevice.PdmDevicePixelRatioScaled:
+            value = 1
         else:
-            value = 0
+            value = super(QwtNullPaintDevice, self).metric(deviceMetric)
         return value
 
     def drawRects(self, rects, rectCount):

qwt/painter_command.py

@@ -18,6 +18,40 @@ import copy
 from qtpy.QtGui import QPaintEngine, QPainterPath
 
 
+def _flag_int(flag):
+    """Return the integer value of a Qt enum/flag (PyQt5 and PyQt6).
+
+    PyQt5 exposes Qt enums as plain ints (``int(flag)`` works). PyQt6 wraps
+    them as ``enum.Flag`` instances which are not ``int`` subclasses, so
+    ``int(flag)`` raises -- the value must be read from ``flag.value``.
+    """
+    try:
+        return flag.value
+    except AttributeError:
+        return int(flag)
+
+
+# Cache QPaintEngine.DirtyXxx flags as plain Python ints once at import time.
+# On PyQt6, Qt enums are full ``enum.Flag`` instances and every ``flags &
+# Member`` test goes through Python's ``enum.__and__`` machinery (~6 us each).
+# In ``QwtPainterCommand.__init__`` below, the State branch performs twelve
+# successive flag tests per painter command -- on PyQt6 alone this accounted
+# for ~20 ms of the residual perf gap on the load test. Casting once to int
+# and bitwise-testing against int constants brings each test back to ~50 ns.
+_DIRTY_PEN = _flag_int(QPaintEngine.DirtyPen)
+_DIRTY_BRUSH = _flag_int(QPaintEngine.DirtyBrush)
+_DIRTY_BRUSH_ORIGIN = _flag_int(QPaintEngine.DirtyBrushOrigin)
+_DIRTY_FONT = _flag_int(QPaintEngine.DirtyFont)
+_DIRTY_BACKGROUND = _flag_int(QPaintEngine.DirtyBackground)
+_DIRTY_TRANSFORM = _flag_int(QPaintEngine.DirtyTransform)
+_DIRTY_CLIP_ENABLED = _flag_int(QPaintEngine.DirtyClipEnabled)
+_DIRTY_CLIP_REGION = _flag_int(QPaintEngine.DirtyClipRegion)
+_DIRTY_CLIP_PATH = _flag_int(QPaintEngine.DirtyClipPath)
+_DIRTY_HINTS = _flag_int(QPaintEngine.DirtyHints)
+_DIRTY_COMPOSITION_MODE = _flag_int(QPaintEngine.DirtyCompositionMode)
+_DIRTY_OPACITY = _flag_int(QPaintEngine.DirtyOpacity)
+
+
 class PixmapData(object):
     def __init__(self):
         self.rect = None
@@ -125,32 +159,35 @@ class QwtPainterCommand(object):
                 self.__type = self.State
                 self.__stateData = StateData()
                 self.__stateData.flags = state.state()
-                if self.__stateData.flags & QPaintEngine.DirtyPen:
+                # Cast to int once: subsequent bitwise tests are done against
+                # the cached _DIRTY_* int constants (see top of module).
+                flags = _flag_int(self.__stateData.flags)
+                if flags & _DIRTY_PEN:
                     self.__stateData.pen = state.pen()
-                if self.__stateData.flags & QPaintEngine.DirtyBrush:
+                if flags & _DIRTY_BRUSH:
                     self.__stateData.brush = state.brush()
-                if self.__stateData.flags & QPaintEngine.DirtyBrushOrigin:
+                if flags & _DIRTY_BRUSH_ORIGIN:
                     self.__stateData.brushOrigin = state.brushOrigin()
-                if self.__stateData.flags & QPaintEngine.DirtyFont:
+                if flags & _DIRTY_FONT:
                     self.__stateData.font = state.font()
-                if self.__stateData.flags & QPaintEngine.DirtyBackground:
+                if flags & _DIRTY_BACKGROUND:
                     self.__stateData.backgroundMode = state.backgroundMode()
                     self.__stateData.backgroundBrush = state.backgroundBrush()
-                if self.__stateData.flags & QPaintEngine.DirtyTransform:
+                if flags & _DIRTY_TRANSFORM:
                     self.__stateData.transform = state.transform()
-                if self.__stateData.flags & QPaintEngine.DirtyClipEnabled:
+                if flags & _DIRTY_CLIP_ENABLED:
                     self.__stateData.isClipEnabled = state.isClipEnabled()
-                if self.__stateData.flags & QPaintEngine.DirtyClipRegion:
+                if flags & _DIRTY_CLIP_REGION:
                     self.__stateData.clipRegion = state.clipRegion()
                     self.__stateData.clipOperation = state.clipOperation()
-                if self.__stateData.flags & QPaintEngine.DirtyClipPath:
+                if flags & _DIRTY_CLIP_PATH:
                     self.__stateData.clipPath = state.clipPath()
                     self.__stateData.clipOperation = state.clipOperation()
-                if self.__stateData.flags & QPaintEngine.DirtyHints:
+                if flags & _DIRTY_HINTS:
                     self.__stateData.renderHints = state.renderHints()
-                if self.__stateData.flags & QPaintEngine.DirtyCompositionMode:
+                if flags & _DIRTY_COMPOSITION_MODE:
                     self.__stateData.compositionMode = state.compositionMode()
-                if self.__stateData.flags & QPaintEngine.DirtyOpacity:
+                if flags & _DIRTY_OPACITY:
                     self.__stateData.opacity = state.opacity()
         elif len(args) == 3:
             rect, pixmap, subRect = args

qwt/plot_canvas.py

@@ -787,7 +787,7 @@ class QwtPlotCanvas(QFrame):
         import warnings
 
         warnings.warn(
-            "`invalidatePaintCache` has been removed: " "please use `replot` instead",
+            "`invalidatePaintCache` has been removed: please use `replot` instead",
             RuntimeWarning,
         )
         self.replot()

qwt/scale_div.py

@@ -235,9 +235,11 @@ class QwtScaleDiv(object):
         :param float value: Value
         :return: True/False
         """
-        min_ = min([self.__lowerBound, self.__upperBound])
-        max_ = max([self.__lowerBound, self.__upperBound])
-        return value >= min_ and value <= max_
+        lb = self.__lowerBound
+        ub = self.__upperBound
+        if lb <= ub:
+            return lb <= value <= ub
+        return ub <= value <= lb
 
     def invert(self):
         """

qwt/scale_draw.py

@@ -24,7 +24,6 @@ from datetime import datetime
 
 from qtpy.QtCore import (
     QLineF,
-    QObject,
     QPoint,
     QPointF,
     QRect,
@@ -39,11 +38,34 @@ from qwt.scale_div import QwtScaleDiv
 from qwt.scale_map import QwtScaleMap
 from qwt.text import QwtText
 
+# Plain-int aliases for Qt alignment flags. Qt6 exposes alignment flags as
+# IntEnum members and bitwise operations on them go through Python's
+# enum machinery (`__and__`/`__call__`), which is one of the dominant costs
+# of label layout. Casting to int once and using these constants makes the
+# bitwise tests in `labelTransformation` ~10x cheaper without changing
+# semantics.
+_ALIGN_LEFT = int(Qt.AlignLeft)
+_ALIGN_RIGHT = int(Qt.AlignRight)
+_ALIGN_TOP = int(Qt.AlignTop)
+_ALIGN_BOTTOM = int(Qt.AlignBottom)
+
+
+class QwtAbstractScaleDraw_PrivateData(object):
+    # See QwtText_PrivateData: ``QObject`` inheritance is unused and the
+    # base class' ``__init__`` is a measurable cost in tick-heavy renders.
+    __slots__ = (
+        "spacing",
+        "penWidth",
+        "minExtent",
+        "components",
+        "tick_length",
+        "tick_lighter_factor",
+        "map",
+        "scaleDiv",
+        "labelCache",
+    )
 
-class QwtAbstractScaleDraw_PrivateData(QObject):
     def __init__(self):
-        QObject.__init__(self)
-
         self.spacing = 4
         self.penWidth = 0
         self.minExtent = 0.0
@@ -470,12 +492,25 @@ class QwtAbstractScaleDraw(object):
         self.__data.labelCache.clear()
 
 
-class QwtScaleDraw_PrivateData(QObject):
-    def __init__(self):
-        QObject.__init__(self)
+class QwtScaleDraw_PrivateData(object):
+    # See QwtText_PrivateData: ``QObject`` inheritance is unused and the
+    # base class' ``__init__`` is a measurable cost in tick-heavy renders.
+    __slots__ = (
+        "len",
+        "alignment",
+        "orientation",
+        "labelAlignment",
+        "labelRotation",
+        "labelAutoSize",
+        "pos",
+    )
 
+    def __init__(self):
         self.len = 0
         self.alignment = QwtScaleDraw.BottomScale
+        # Cached orientation - kept in sync by ``QwtScaleDraw.setAlignment``
+        # so that the very hot ``orientation()`` accessor avoids any test.
+        self.orientation = Qt.Horizontal
         self.labelAlignment = 0
         self.labelRotation = 0.0
         self.labelAutoSize = True
@@ -554,6 +589,11 @@ class QwtScaleDraw(QwtAbstractScaleDraw):
             :py:meth:`alignment()`
         """
         self.__data.alignment = align
+        # Keep cached orientation in sync (see ``orientation()``).
+        if align == self.BottomScale or align == self.TopScale:
+            self.__data.orientation = Qt.Horizontal
+        else:
+            self.__data.orientation = Qt.Vertical
 
     def orientation(self):
         """
@@ -568,10 +608,8 @@ class QwtScaleDraw(QwtAbstractScaleDraw):
 
             :py:meth:`alignment()`
         """
-        if self.__data.alignment in (self.TopScale, self.BottomScale):
-            return Qt.Horizontal
-        elif self.__data.alignment in (self.LeftScale, self.RightScale):
-            return Qt.Vertical
+        # Pre-computed by ``setAlignment`` - this method is called per tick.
+        return self.__data.orientation
 
     def getBorderDistHint(self, font):
         """
@@ -597,17 +635,19 @@ class QwtScaleDraw(QwtAbstractScaleDraw):
         if len(ticks) == 0:
             return start, end
 
+        scale_map = self.scaleMap()
+        transform = scale_map.transform
         minTick = ticks[0]
-        minPos = self.scaleMap().transform(minTick)
+        minPos = transform(minTick)
         maxTick = minTick
         maxPos = minPos
 
         for tick in ticks:
-            tickPos = self.scaleMap().transform(tick)
+            tickPos = transform(tick)
             if tickPos < minPos:
                 minTick = tick
                 minPos = tickPos
-            if tickPos > self.scaleMap().transform(maxTick):
+            if tickPos > maxPos:
                 maxTick = tick
                 maxPos = tickPos
 
@@ -615,16 +655,16 @@ class QwtScaleDraw(QwtAbstractScaleDraw):
         e = 0.0
         if self.orientation() == Qt.Vertical:
             s = -self.labelRect(font, minTick).top()
-            s -= abs(minPos - round(self.scaleMap().p2()))
+            s -= abs(minPos - round(scale_map.p2()))
 
             e = self.labelRect(font, maxTick).bottom()
-            e -= abs(maxPos - self.scaleMap().p1())
+            e -= abs(maxPos - scale_map.p1())
         else:
             s = -self.labelRect(font, minTick).left()
-            s -= abs(minPos - self.scaleMap().p1())
+            s -= abs(minPos - scale_map.p1())
 
             e = self.labelRect(font, maxTick).right()
-            e -= abs(maxPos - self.scaleMap().p2())
+            e -= abs(maxPos - scale_map.p2())
 
         return max(math.ceil(s), 0), max(math.ceil(e), 0)
 
@@ -763,27 +803,22 @@ class QwtScaleDraw(QwtAbstractScaleDraw):
         """
         tval = self.scaleMap().transform(value)
         dist = self.spacing()
-        if self.hasComponent(QwtAbstractScaleDraw.Backbone):
-            dist += max([1, self.penWidth()])
-        if self.hasComponent(QwtAbstractScaleDraw.Ticks):
+        hasComponent = self.hasComponent
+        if hasComponent(QwtAbstractScaleDraw.Backbone):
+            dist += max(1, self.penWidth())
+        if hasComponent(QwtAbstractScaleDraw.Ticks):
             dist += self.tickLength(QwtScaleDiv.MajorTick)
 
-        px = 0
-        py = 0
-        if self.alignment() == self.RightScale:
-            px = self.__data.pos.x() + dist
-            py = tval
-        elif self.alignment() == self.LeftScale:
-            px = self.__data.pos.x() - dist
-            py = tval
-        elif self.alignment() == self.BottomScale:
-            px = tval
-            py = self.__data.pos.y() + dist
-        elif self.alignment() == self.TopScale:
-            px = tval
-            py = self.__data.pos.y() - dist
-
-        return QPointF(px, py)
+        alignment = self.alignment()
+        pos = self.__data.pos
+        if alignment == self.RightScale:
+            return QPointF(pos.x() + dist, tval)
+        if alignment == self.LeftScale:
+            return QPointF(pos.x() - dist, tval)
+        if alignment == self.BottomScale:
+            return QPointF(tval, pos.y() + dist)
+        # TopScale
+        return QPointF(tval, pos.y() - dist)
 
     def drawTick(self, painter, value, len_):
         """
@@ -1007,17 +1042,19 @@ class QwtScaleDraw(QwtAbstractScaleDraw):
         flags = self.labelAlignment()
         if flags == 0:
             flags = self.Flags[self.alignment()]
+        # Cast to plain int once to avoid the per-bit Qt6 enum overhead.
+        flags = int(flags)
 
-        if flags & Qt.AlignLeft:
+        if flags & _ALIGN_LEFT:
             x = -size.width()
-        elif flags & Qt.AlignRight:
+        elif flags & _ALIGN_RIGHT:
             x = 0.0
         else:
             x = -(0.5 * size.width())
 
-        if flags & Qt.AlignTop:
+        if flags & _ALIGN_TOP:
             y = -size.height()
-        elif flags & Qt.AlignBottom:
+        elif flags & _ALIGN_BOTTOM:
             y = 0
         else:
             y = -(0.5 * size.height())
@@ -1039,6 +1076,31 @@ class QwtScaleDraw(QwtAbstractScaleDraw):
         lbl, labelSize = self.tickLabel(font, value)
         if not lbl or lbl.isEmpty():
             return QRectF(0.0, 0.0, 0.0, 0.0)
+        # Fast path: when the label is not rotated, the contribution of
+        # ``pos`` cancels out (transform.translate(pos) followed by
+        # br.translate(-pos)). This avoids ``labelPosition``,
+        # ``labelTransformation`` and ``QTransform.mapRect`` entirely - all
+        # of which are dominant costs in tick-heavy layouts.
+        if self.labelRotation() == 0.0:
+            flags = self.labelAlignment()
+            if flags == 0:
+                flags = self.Flags[self.alignment()]
+            flags = int(flags)
+            w = labelSize.width()
+            h = labelSize.height()
+            if flags & _ALIGN_LEFT:
+                x = -w
+            elif flags & _ALIGN_RIGHT:
+                x = 0.0
+            else:
+                x = -0.5 * w
+            if flags & _ALIGN_TOP:
+                y = -h
+            elif flags & _ALIGN_BOTTOM:
+                y = 0.0
+            else:
+                y = -0.5 * h
+            return QRectF(x, y, w, h)
         pos = self.labelPosition(value)
         transform = self.labelTransformation(pos, labelSize)
         br = transform.mapRect(QRectF(QPointF(0, 0), labelSize))

qwt/scale_engine.py

@@ -324,11 +324,10 @@ class QwtScaleEngine(object):
         """
         if not interval.isValid():
             return False
-        eps = abs(1.0e-6 * interval.width())
-        if interval.minValue() - value > eps or value - interval.maxValue() > eps:
-            return False
-        else:
-            return True
+        min_v = interval.minValue()
+        max_v = interval.maxValue()
+        eps = abs(1.0e-6 * (max_v - min_v))
+        return not (min_v - value > eps or value - max_v > eps)
 
     def strip(self, ticks, interval):
         """
@@ -340,9 +339,17 @@ class QwtScaleEngine(object):
         """
         if not interval.isValid() or not ticks:
             return []
-        if self.contains(interval, ticks[0]) and self.contains(interval, ticks[-1]):
+        # Inline ``contains`` to avoid one Python call per tick: ``strip`` is
+        # called by buildTicks for every layout pass and is one of the
+        # dominant costs in tick-heavy plots.
+        min_v = interval.minValue()
+        max_v = interval.maxValue()
+        eps = abs(1.0e-6 * (max_v - min_v))
+        lo = min_v - eps
+        hi = max_v + eps
+        if lo <= ticks[0] and ticks[-1] <= hi:
             return ticks
-        return [tick for tick in ticks if self.contains(interval, tick)]
+        return [tick for tick in ticks if lo <= tick <= hi]
 
     def buildInterval(self, value):
         """
@@ -594,7 +601,7 @@ class QwtLinearScaleEngine(QwtScaleEngine):
         numTicks = int(math.ceil(abs(stepSize / minStep)) - 1)
         medIndex = -1
         if numTicks % 2:
-            medIndex = numTicks / 2
+            medIndex = numTicks // 2
         for val in ticks[QwtScaleDiv.MajorTick]:
             for k in range(numTicks):
                 val += minStep
@@ -837,7 +844,7 @@ class QwtLogScaleEngine(QwtScaleEngine):
 
             mediumTickIndex = -1
             if numSteps > 2 and numSteps % 2 == 0:
-                mediumTickIndex = numSteps / 2
+                mediumTickIndex = numSteps // 2
 
             for v in ticks[QwtScaleDiv.MajorTick]:
                 s = logBase / numSteps
@@ -872,7 +879,7 @@ class QwtLogScaleEngine(QwtScaleEngine):
 
             mediumTickIndex = -1
             if numTicks > 2 and numTicks % 2:
-                mediumTickIndex = numTicks / 2
+                mediumTickIndex = numTicks // 2
 
             minFactor = max([math.pow(logBase, minStep), float(logBase)])
 

qwt/scale_map.py

@@ -217,8 +217,12 @@ class QwtScaleMap(object):
         if self.__transform:
             self.__ts1 = self.__transform.transform(self.__ts1)
             ts2 = self.__transform.transform(ts2)
-        self.__cnv = 1.0
-        if self.__ts1 != ts2:
+        if self.__ts1 == ts2:
+            # Degenerate scale: collapse every value to ``p1`` (matches the
+            # symmetric guard in ``invTransform_scalar`` and the C++ Qwt
+            # behaviour).
+            self.__cnv = 0.0
+        else:
             self.__cnv = (self.__p2 - self.__p1) / (ts2 - self.__ts1)
 
     def transform(self, *args):
@@ -245,13 +249,18 @@ class QwtScaleMap(object):
 
             :py:meth:`invTransform()`
         """
-        if len(args) == 1:
-            # Scalar transform
-            return self.transform_scalar(args[0])
-        elif len(args) == 3 and isinstance(args[2], QPointF):
+        nargs = len(args)
+        if nargs == 1:
+            # Scalar transform: inline the fast path for the dominant case
+            # (avoids one Python call frame per tick label).
+            s = args[0]
+            if self.__transform:
+                s = self.__transform.transform(s)
+            return self.__p1 + (s - self.__ts1) * self.__cnv
+        elif nargs == 3 and isinstance(args[2], QPointF):
             xMap, yMap, pos = args
             return QPointF(xMap.transform(pos.x()), yMap.transform(pos.y()))
-        elif len(args) == 3 and isinstance(args[2], QRectF):
+        elif nargs == 3 and isinstance(args[2], QRectF):
             xMap, yMap, rect = args
             x1 = xMap.transform(rect.left())
             x2 = xMap.transform(rect.right())
@@ -269,7 +278,7 @@ class QwtScaleMap(object):
                 y1 = 0.0
             if qwtFuzzyCompare(y2, 0.0, y2 - y1) == 0:
                 y2 = 0.0
-            return QRectF(x1, y1, x2 - x1 + 1, y2 - y1 + 1)
+            return QRectF(x1, y1, x2 - x1, y2 - y1)
         else:
             raise TypeError(
                 "%s().transform() takes 1 or 3 argument(s) (%s "
@@ -292,8 +301,8 @@ class QwtScaleMap(object):
         elif isinstance(args[2], QRectF):
             xMap, yMap, rect = args
             x1 = xMap.invTransform(rect.left())
-            x2 = xMap.invTransform(rect.right() - 1)
+            x2 = xMap.invTransform(rect.right())
             y1 = yMap.invTransform(rect.top())
-            y2 = yMap.invTransform(rect.bottom() - 1)
+            y2 = yMap.invTransform(rect.bottom())
             r = QRectF(x1, y1, x2 - x1, y2 - y1)
             return r.normalized()

qwt/tests/test_bodedemo.py

@@ -144,8 +144,7 @@ class BodePlot(QwtPlot):
             yvalue=-20.0,
             align=Qt.AlignRight | Qt.AlignBottom,
             label=QwtText.make(
-                "[1-(\u03c9/\u03c9<sub>0</sub>)<sup>2</sup>+2j\u03c9/Q]"
-                "<sup>-1</sup>",
+                "[1-(\u03c9/\u03c9<sub>0</sub>)<sup>2</sup>+2j\u03c9/Q]<sup>-1</sup>",
                 color=Qt.white,
                 borderradius=2,
                 borderpen=QPen(Qt.lightGray, 5),

qwt/tests/test_relativemargin.py

@@ -30,9 +30,9 @@ class RelativeMarginDemo(QW.QWidget):
                 def_margin = plot.axisMargin(qwt.QwtPlot.yLeft)
                 scale_str = "lin/lin" if not log_scale else "log/lin"
                 if relative_margin is None:
-                    margin_str = f"default ({def_margin*100:.0f}%)"
+                    margin_str = f"default ({def_margin * 100:.0f}%)"
                 else:
-                    margin_str = f"{relative_margin*100:.0f}%"
+                    margin_str = f"{relative_margin * 100:.0f}%"
                 plot.setTitle(f"{scale_str}, margin: {margin_str}")
                 if relative_margin is not None:
                     plot.setAxisMargin(qwt.QwtPlot.yLeft, relative_margin)

qwt/text.py

@@ -72,13 +72,34 @@ QWIDGETSIZE_MAX = (1 << 24) - 1
 QT_API = os.environ["QT_API"]
 
 
+# Cache Qt alignment flags as plain ints once at import time. On PyQt6 these
+# are ``Qt.AlignmentFlag`` enum members and every bitwise test goes through
+# ``enum.__and__`` (~6 us each). The test code below combines them in hot
+# paths called per-tick / per-label / per-paint event.
+def _flag_int(flag):
+    """Return the integer value of a Qt enum/flag (PyQt5 and PyQt6)."""
+    try:
+        return flag.value
+    except AttributeError:
+        return int(flag)
+
+
+_ALIGN_LEFT = _flag_int(Qt.AlignLeft)
+_ALIGN_RIGHT = _flag_int(Qt.AlignRight)
+_ALIGN_TOP = _flag_int(Qt.AlignTop)
+_ALIGN_BOTTOM = _flag_int(Qt.AlignBottom)
+_ALIGN_HCENTER = _flag_int(Qt.AlignHCenter)
+_ALIGN_JUSTIFY = _flag_int(Qt.AlignJustify)
+_ALIGN_CENTER = _flag_int(Qt.AlignCenter)
+
+
 def taggedRichText(text, flags):
     richText = text
-    if flags & Qt.AlignJustify:
+    if flags & _ALIGN_JUSTIFY:
         richText = '<div align="justify">' + richText + "</div>"
-    elif flags & Qt.AlignRight:
+    elif flags & _ALIGN_RIGHT:
         richText = '<div align="right">' + richText + "</div>"
-    elif flags & Qt.AlignHCenter:
+    elif flags & _ALIGN_HCENTER:
         richText = '<div align="center">' + richText + "</div>"
     return richText
 
@@ -189,6 +210,65 @@ class QwtTextEngine(object):
 
 ASCENTCACHE = {}
 
+# 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:
+#
+# 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()``.
+#
+# 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
+
+
+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(),
+    )
+
+
+def font_key_cached(font):
+    """Return a hashable cache key uniquely identifying ``font`` for metrics.
+
+    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).
+    """
+    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
+
 
 def get_screen_resolution():
     """Return screen resolution: tuple of floats (DPIx, DPIy)"""
@@ -226,16 +306,21 @@ class QwtPlainTextEngine(QwtTextEngine):
         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
 
     def fontmetrics(self, font):
-        fid = font.toString()
+        fid = font_key_cached(font)
         try:
             return self._fm_cache[fid]
         except KeyError:
             return self._fm_cache.setdefault(fid, QFontMetrics(font))
 
     def fontmetrics_f(self, font):
-        fid = font.toString()
+        fid = font_key_cached(font)
         try:
             return self._fm_cache_f[fid]
         except KeyError:
@@ -270,7 +355,7 @@ class QwtPlainTextEngine(QwtTextEngine):
 
     def effectiveAscent(self, font):
         global ASCENTCACHE
-        fontKey = font.key()
+        fontKey = font_key_cached(font)
         ascent = ASCENTCACHE.get(fontKey)
         if ascent is not None:
             return ascent
@@ -317,11 +402,19 @@ class QwtPlainTextEngine(QwtTextEngine):
         :param QFont font: Font of the text
         :return: tuple (left, right, top, bottom) representing margins
         """
-        left = right = 0
-        fm = self.fontmetrics(font)
-        top = fm.ascent() - self.effectiveAscent(font)
-        bottom = fm.descent()
-        return left, right, top, bottom
+        # 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())
+            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):
         """
@@ -464,10 +557,26 @@ class QwtRichTextEngine(QwtTextEngine):
         return 0, 0, 0, 0
 
 
-class QwtText_PrivateData(QObject):
-    def __init__(self):
-        QObject.__init__(self)
+class QwtText_PrivateData(object):
+    # ``QObject`` was previously used as the base class but no Qt signals
+    # or events are ever emitted from ``_PrivateData`` containers and the
+    # ``QObject.__init__`` call dominates ``QwtText.__init__`` (it is the
+    # single most expensive line for tick-label-heavy renders, see
+    # https://github.com/PlotPyStack/PythonQwt/issues/93).
+    __slots__ = (
+        "renderFlags",
+        "borderRadius",
+        "borderPen",
+        "backgroundBrush",
+        "paintAttributes",
+        "layoutAttributes",
+        "textEngine",
+        "text",
+        "font",
+        "color",
+    )
 
+    def __init__(self):
         self.renderFlags = Qt.AlignCenter
         self.borderRadius = 0
         self.borderPen = Qt.NoPen
@@ -484,10 +593,13 @@ class QwtText_PrivateData(QObject):
 class QwtText_LayoutCache(object):
     def __init__(self):
         self.textSize = None
-        self.font = None
+        self.fontKey = None
+        self.fontId = -1
 
     def invalidate(self):
         self.textSize = None
+        self.fontKey = None
+        self.fontId = -1
 
 
 class QwtText(object):
@@ -727,7 +839,13 @@ class QwtText(object):
             :py:meth:`renderFlags()`,
             :py:meth:`qwt.text.QwtTextEngine.draw()`
         """
-        renderFlags = Qt.AlignmentFlag(renderFlags)
+        # Wrap into Qt.AlignmentFlag so that downstream Qt APIs (notably
+        # ``QTextOption.setAlignment``, ``QPainter.drawText``,
+        # ``QFontMetrics.boundingRect``) that strictly require an enum on
+        # PyQt6 keep working. Hot bitwise-test sites locally cast back to
+        # int to avoid the per-test enum.__and__ cost.
+        if not isinstance(renderFlags, Qt.AlignmentFlag):
+            renderFlags = Qt.AlignmentFlag(renderFlags)
         if renderFlags != self.__data.renderFlags:
             self.__data.renderFlags = renderFlags
             self.__layoutCache.invalidate()
@@ -994,17 +1112,24 @@ class QwtText(object):
         :param QFont defaultFont Font, used for the calculation if the text has no font
         :return: Caluclated size
         """
-        font = QFont(self.usedFont(defaultFont))
-        if (
-            self.__layoutCache.textSize is None
-            or not self.__layoutCache.textSize.isValid()
-            or self.__layoutCache.font is not font
-        ):
-            self.__layoutCache.textSize = self.__data.textEngine.textSize(
-                font, self.__data.renderFlags, self.__data.text
-            )
-            self.__layoutCache.font = font
-        sz = self.__layoutCache.textSize
+        font = self.usedFont(defaultFont)
+        cache = self.__layoutCache
+        font_id = id(font)
+        if cache.textSize is not None and cache.fontId == font_id:
+            sz = QSizeF(cache.textSize)
+        else:
+            fkey = font_key_cached(font)
+            if (
+                cache.textSize is None
+                or not cache.textSize.isValid()
+                or cache.fontKey != fkey
+            ):
+                cache.textSize = self.__data.textEngine.textSize(
+                    font, self.__data.renderFlags, self.__data.text
+                )
+                cache.fontKey = fkey
+            cache.fontId = font_id
+            sz = QSizeF(cache.textSize)
         if self.__data.layoutAttributes & self.MinimumLayout:
             (left, right, top, bottom) = self.__data.textEngine.textMargins(font)
             sz -= QSizeF(left + right, top + bottom)
@@ -1072,7 +1197,13 @@ class QwtText(object):
             return self.__map.get(format_)
         elif format_ is not None:
             if format_ == QwtText.AutoText:
-                for key, engine in list(self.__map.items()):
+                # Fast path: a string with no ``<`` cannot be rich text, so
+                # we can return the plain engine without iterating the map
+                # and calling Qt.mightBeRichText (which is a hot Qt call
+                # for tick labels like " 1.5").
+                if "<" not in text:
+                    return self.__map[QwtText.PlainText]
+                for key, engine in self.__map.items():
                     if key != QwtText.PlainText:
                         if engine and engine.mightRender(text):
                             return engine
@@ -1291,10 +1422,10 @@ class QwtTextLabel(QFrame):
         if indent <= 0:
             indent = self.defaultIndent()
         if indent > 0:
-            align = self.__data.text.renderFlags()
-            if align & Qt.AlignLeft or align & Qt.AlignRight:
+            align = _flag_int(self.__data.text.renderFlags())
+            if align & (_ALIGN_LEFT | _ALIGN_RIGHT):
                 mw += self.__data.indent
-            elif align & Qt.AlignTop or align & Qt.AlignBottom:
+            elif align & (_ALIGN_TOP | _ALIGN_BOTTOM):
                 mh += self.__data.indent
         sz += QSizeF(mw, mh)
         return QSize(math.ceil(sz.width()), math.ceil(sz.height()))
@@ -1304,15 +1435,15 @@ class QwtTextLabel(QFrame):
         :param int width: Width
         :return: Preferred height for this widget, given the width.
         """
-        renderFlags = self.__data.text.renderFlags()
+        renderFlags = _flag_int(self.__data.text.renderFlags())
         indent = self.__data.indent
         if indent <= 0:
             indent = self.defaultIndent()
         width -= 2 * self.frameWidth()
-        if renderFlags & Qt.AlignLeft or renderFlags & Qt.AlignRight:
+        if renderFlags & (_ALIGN_LEFT | _ALIGN_RIGHT):
             width -= indent
         height = math.ceil(self.__data.text.heightForWidth(width, self.font()))
-        if renderFlags & Qt.AlignTop or renderFlags & Qt.AlignBottom:
+        if renderFlags & (_ALIGN_TOP | _ALIGN_BOTTOM):
             height += indent
         height += 2 * self.frameWidth()
         return height
@@ -1372,14 +1503,14 @@ class QwtTextLabel(QFrame):
             if indent <= 0:
                 indent = self.defaultIndent()
             if indent > 0:
-                renderFlags = self.__data.text.renderFlags()
-                if renderFlags & Qt.AlignLeft:
+                renderFlags = _flag_int(self.__data.text.renderFlags())
+                if renderFlags & _ALIGN_LEFT:
                     r.setX(r.x() + indent)
-                elif renderFlags & Qt.AlignRight:
+                elif renderFlags & _ALIGN_RIGHT:
                     r.setWidth(r.width() - indent)
-                elif renderFlags & Qt.AlignTop:
+                elif renderFlags & _ALIGN_TOP:
                     r.setY(r.y() + indent)
-                elif renderFlags & Qt.AlignBottom:
+                elif renderFlags & _ALIGN_BOTTOM:
                     r.setHeight(r.height() - indent)
         return r