PythonQwt 0.14.5__tar.gz → 0.15.0__tar.gz

{pythonqwt-0.14.5/PythonQwt.egg-info → pythonqwt-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.14.5
+Version: 0.15.0
 Summary: Qt plotting widgets for Python
 Author-email: Pierre Raybaut <pierre.raybaut@gmail.com>
 License: PythonQwt License Agreement
@@ -736,8 +736,8 @@ plot.insertLegend(qwt.QwtLegend(), qwt.QwtPlot.BottomLegend)
 
 # Create two curves and attach them to plot
 x = np.linspace(-10, 10, 500)
-qwt.QwtPlotCurve.make(x, np.cos(x), "Cosinus", plot, linecolor="red", antialiased=True)
-qwt.QwtPlotCurve.make(x, np.sin(x), "Sinus", plot, linecolor="blue", antialiased=True)
+qwt.QwtPlotCurve.make(x, np.cos(x), "Cosine", plot, linecolor="red", antialiased=True)
+qwt.QwtPlotCurve.make(x, np.sin(x), "Sine", plot, linecolor="blue", antialiased=True)
 
 # Resize and show plot
 plot.resize(600, 300)

{pythonqwt-0.14.5 → pythonqwt-0.15.0/PythonQwt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.14.5
+Version: 0.15.0
 Summary: Qt plotting widgets for Python
 Author-email: Pierre Raybaut <pierre.raybaut@gmail.com>
 License: PythonQwt License Agreement
@@ -736,8 +736,8 @@ plot.insertLegend(qwt.QwtLegend(), qwt.QwtPlot.BottomLegend)
 
 # Create two curves and attach them to plot
 x = np.linspace(-10, 10, 500)
-qwt.QwtPlotCurve.make(x, np.cos(x), "Cosinus", plot, linecolor="red", antialiased=True)
-qwt.QwtPlotCurve.make(x, np.sin(x), "Sinus", plot, linecolor="blue", antialiased=True)
+qwt.QwtPlotCurve.make(x, np.cos(x), "Cosine", plot, linecolor="red", antialiased=True)
+qwt.QwtPlotCurve.make(x, np.sin(x), "Sine", plot, linecolor="blue", antialiased=True)
 
 # Resize and show plot
 plot.resize(600, 300)

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/README.md

@@ -33,8 +33,8 @@ plot.insertLegend(qwt.QwtLegend(), qwt.QwtPlot.BottomLegend)
 
 # Create two curves and attach them to plot
 x = np.linspace(-10, 10, 500)
-qwt.QwtPlotCurve.make(x, np.cos(x), "Cosinus", plot, linecolor="red", antialiased=True)
-qwt.QwtPlotCurve.make(x, np.sin(x), "Sinus", plot, linecolor="blue", antialiased=True)
+qwt.QwtPlotCurve.make(x, np.cos(x), "Cosine", plot, linecolor="red", antialiased=True)
+qwt.QwtPlotCurve.make(x, np.sin(x), "Sine", plot, linecolor="blue", antialiased=True)
 
 # Resize and show plot
 plot.resize(600, 300)

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/doc/plot_example.py

@@ -10,8 +10,8 @@ app = QW.QApplication([])
 x = np.linspace(-10, 10, 500)
 plot = qwt.QwtPlot("Trigonometric functions")
 plot.insertLegend(qwt.QwtLegend(), qwt.QwtPlot.BottomLegend)
-qwt.QwtPlotCurve.make(x, np.cos(x), "Cosinus", plot, linecolor="red", antialiased=True)
-qwt.QwtPlotCurve.make(x, np.sin(x), "Sinus", plot, linecolor="blue", antialiased=True)
+qwt.QwtPlotCurve.make(x, np.cos(x), "Cosine", plot, linecolor="red", antialiased=True)
+qwt.QwtPlotCurve.make(x, np.sin(x), "Sine", plot, linecolor="blue", antialiased=True)
 qth.take_screenshot(
     plot,
     osp.join(osp.abspath(osp.dirname(__file__)), "_static", "QwtPlot_example.png"),

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/qwt/__init__.py

@@ -48,14 +48,22 @@ from qwt.plot_series import (  # noqa: F401
     QwtSeriesStore,
 )
 from qwt.scale_div import QwtScaleDiv  # noqa: F401
-from qwt.scale_draw import QwtAbstractScaleDraw, QwtScaleDraw  # noqa: F401
-from qwt.scale_engine import QwtLinearScaleEngine, QwtLogScaleEngine  # noqa: F401
+from qwt.scale_draw import (  # noqa: F401
+    QwtAbstractScaleDraw,
+    QwtDateTimeScaleDraw,
+    QwtScaleDraw,
+)
+from qwt.scale_engine import (  # noqa: F401
+    QwtDateTimeScaleEngine,
+    QwtLinearScaleEngine,
+    QwtLogScaleEngine,
+)
 from qwt.scale_map import QwtScaleMap  # noqa: F401
 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.14.5"
+__version__ = "0.15.0"
 QWT_VERSION_STR = "6.1.5"
 
 
@@ -132,28 +140,28 @@ class QwtSymbol(QSbl):
 class QwtPlotGrid(QPG):
     def majPen(self):
         warnings.warn(
-            "`majPen` has been removed in Qwt6: " "please use `majorPen` instead",
+            "`majPen` has been removed in Qwt6: please use `majorPen` instead",
             RuntimeWarning,
         )
         return self.majorPen()
 
     def minPen(self):
         warnings.warn(
-            "`minPen` has been removed in Qwt6: " "please use `minorPen` instead",
+            "`minPen` has been removed in Qwt6: please use `minorPen` instead",
             RuntimeWarning,
         )
         return self.minorPen()
 
     def setMajPen(self, *args):
         warnings.warn(
-            "`setMajPen` has been removed in Qwt6: " "please use `setMajorPen` instead",
+            "`setMajPen` has been removed in Qwt6: please use `setMajorPen` instead",
             RuntimeWarning,
         )
         return self.setMajorPen(*args)
 
     def setMinPen(self, *args):
         warnings.warn(
-            "`setMinPen` has been removed in Qwt6: " "please use `setMinorPen` instead",
+            "`setMinPen` has been removed in Qwt6: please use `setMinorPen` instead",
             RuntimeWarning,
         )
         return self.setMinorPen(*args)

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/qwt/plot.py

@@ -132,8 +132,8 @@ class QwtPlot(QFrame):
         x = np.linspace(-10, 10, 500)
         plot = qwt.QwtPlot("Trigonometric functions")
         plot.insertLegend(qwt.QwtLegend(), qwt.QwtPlot.BottomLegend)
-        qwt.QwtPlotCurve.make(x, np.cos(x), "Cosinus", plot, linecolor="red", antialiased=True)
-        qwt.QwtPlotCurve.make(x, np.sin(x), "Sinus", plot, linecolor="blue", antialiased=True)
+        qwt.QwtPlotCurve.make(x, np.cos(x), "Cosine", plot, linecolor="red", antialiased=True)
+        qwt.QwtPlotCurve.make(x, np.sin(x), "Sine", plot, linecolor="blue", antialiased=True)
         plot.resize(600, 300)
         plot.show()
 
@@ -2137,7 +2137,7 @@ class QwtPlotItem(object):
         import warnings
 
         warnings.warn(
-            "`setAxis` has been removed in Qwt6: " "please use `setAxes` instead",
+            "`setAxis` has been removed in Qwt6: please use `setAxes` instead",
             RuntimeWarning,
         )
         self.setAxes(xAxis, yAxis)

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/qwt/plot_canvas.py

@@ -13,7 +13,7 @@ QwtPlotCanvas
    :members:
 """
 
-import os
+from collections.abc import Sequence
 
 from qtpy.QtCore import QEvent, QObject, QPoint, QPointF, QRect, QRectF, QSize, Qt
 from qtpy.QtGui import (
@@ -34,8 +34,6 @@ from qtpy.QtWidgets import QFrame, QStyle, QStyleOption, QStyleOptionFrame
 from qwt.null_paintdevice import QwtNullPaintDevice
 from qwt.painter import QwtPainter
 
-QT_API = os.environ["QT_API"]
-
 
 class Border(object):
     def __init__(self):
@@ -71,17 +69,15 @@ class QwtStyleSheetRecorder(QwtNullPaintDevice):
             self.__origin = state.brushOrigin()
 
     def drawRects(self, rects, count):
-        if QT_API.startswith("pyside"):
-            # Pyside
-            if isinstance(rects, (QRect, QRectF)):
-                self.border.list = [rects]
-            else:
-                for i in range(count):
-                    self.border.rectList += [rects.getRect().index(i)]
+        if isinstance(rects, (QRect, QRectF)):
+            self.border.rectList = [QRectF(rects)]
+        elif isinstance(rects, Sequence):
+            self.border.rectList.extend(QRectF(rects[i]) for i in range(count))
         else:
-            # PyQt
-            for i in range(count):
-                self.border.rectList += [rects[i]]
+            raise TypeError(
+                "drawRects() expects a QRect, QRectF or a sequence of them, "
+                f"but got {type(rects).__name__}"
+            )
 
     def drawPath(self, path):
         rect = QRectF(QPointF(0.0, 0.0), self.__size)

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/qwt/scale_draw.py

@@ -20,6 +20,7 @@ QwtScaleDraw
 """
 
 import math
+from datetime import datetime
 
 from qtpy.QtCore import (
     QLineF,
@@ -1218,3 +1219,62 @@ class QwtScaleDraw(QwtAbstractScaleDraw):
             sm.setPaintInterval(pos.y() + len_, pos.y())
         else:
             sm.setPaintInterval(pos.x(), pos.x() + len_)
+
+
+class QwtDateTimeScaleDraw(QwtScaleDraw):
+    """Scale draw for datetime axis
+
+    This class formats axis labels as date/time strings from Unix timestamps.
+
+    Args:
+        format: Format string for datetime display (default: "%Y-%m-%d %H:%M:%S").
+                Uses Python datetime.strftime() format codes.
+        spacing: Spacing between labels (default: 4)
+
+    Examples:
+        >>> # Create a datetime scale with default format
+        >>> scale = QwtDateTimeScaleDraw()
+
+        >>> # Create a datetime scale with custom format (time only)
+        >>> scale = QwtDateTimeScaleDraw(format="%H:%M:%S")
+
+        >>> # Create a datetime scale with date only
+        >>> scale = QwtDateTimeScaleDraw(format="%Y-%m-%d", spacing=4)
+    """
+
+    def __init__(self, format: str = "%Y-%m-%d %H:%M:%S", spacing: int = 4) -> None:
+        super().__init__()
+        self._format = format
+        self.setSpacing(spacing)
+
+    def get_format(self) -> str:
+        """Get the current datetime format string
+
+        Returns:
+            str: Format string
+        """
+        return self._format
+
+    def set_format(self, format: str) -> None:
+        """Set the datetime format string
+
+        Args:
+            format: Format string for datetime display
+        """
+        self._format = format
+
+    def label(self, value: float) -> QwtText:
+        """Convert a timestamp value to a formatted date/time label
+
+        Args:
+            value: Unix timestamp (seconds since epoch)
+
+        Returns:
+            QwtText: Formatted label
+        """
+        try:
+            dt = datetime.fromtimestamp(value)
+            return QwtText(dt.strftime(self._format))
+        except (ValueError, OSError):
+            # Handle invalid timestamps
+            return QwtText("")

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/qwt/scale_engine.py

@@ -906,3 +906,175 @@ class QwtLogScaleEngine(QwtScaleEngine):
             x2 = interval.maxValue()
 
         return qwtPowInterval(self.base(), QwtInterval(x1, x2))
+
+
+class QwtDateTimeScaleEngine(QwtLinearScaleEngine):
+    """
+    A scale engine for datetime scales that creates intelligent time-based tick intervals.
+
+    This engine calculates tick intervals that correspond to meaningful time units
+    (seconds, minutes, hours, days, weeks, months, years) rather than arbitrary
+    numerical spacing.
+    """
+
+    # Time intervals in seconds
+    TIME_INTERVALS = [
+        1,  # 1 second
+        5,  # 5 seconds
+        10,  # 10 seconds
+        15,  # 15 seconds
+        30,  # 30 seconds
+        60,  # 1 minute
+        2 * 60,  # 2 minutes
+        5 * 60,  # 5 minutes
+        10 * 60,  # 10 minutes
+        15 * 60,  # 15 minutes
+        30 * 60,  # 30 minutes
+        60 * 60,  # 1 hour
+        2 * 60 * 60,  # 2 hours
+        3 * 60 * 60,  # 3 hours
+        6 * 60 * 60,  # 6 hours
+        12 * 60 * 60,  # 12 hours
+        24 * 60 * 60,  # 1 day
+        2 * 24 * 60 * 60,  # 2 days
+        7 * 24 * 60 * 60,  # 1 week
+        2 * 7 * 24 * 60 * 60,  # 2 weeks
+        30 * 24 * 60 * 60,  # 1 month (approx)
+        3 * 30 * 24 * 60 * 60,  # 3 months (approx)
+        6 * 30 * 24 * 60 * 60,  # 6 months (approx)
+        365 * 24 * 60 * 60,  # 1 year (approx)
+    ]
+
+    def __init__(self, base=10):
+        super(QwtDateTimeScaleEngine, self).__init__(base)
+
+    def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.0):
+        """
+        Calculate a scale division for a datetime interval
+
+        :param float x1: First interval limit (Unix timestamp)
+        :param float x2: Second interval limit (Unix timestamp)
+        :param int maxMajorSteps: Maximum for the number of major steps
+        :param int maxMinorSteps: Maximum number of minor steps
+        :param float stepSize: Step size. If stepSize == 0.0, calculates intelligent datetime step
+        :return: Calculated scale division
+        """
+        interval = QwtInterval(x1, x2).normalized()
+        if interval.width() <= 0:
+            return QwtScaleDiv()
+
+        # If stepSize is provided and > 0, use parent implementation
+        if stepSize > 0.0:
+            return super(QwtDateTimeScaleEngine, self).divideScale(
+                x1, x2, maxMajorSteps, maxMinorSteps, stepSize
+            )
+
+        # Calculate intelligent datetime step size
+        duration = interval.width()  # Duration in seconds
+
+        # Find the best time interval for the given duration and max steps
+        best_step = self._find_best_time_step(duration, maxMajorSteps)
+
+        # Use the calculated datetime step
+        scaleDiv = QwtScaleDiv()
+        if best_step > 0.0:
+            ticks = self.buildTicks(interval, best_step, maxMinorSteps)
+            scaleDiv = QwtScaleDiv(interval, ticks)
+
+        if x1 > x2:
+            scaleDiv.invert()
+
+        return scaleDiv
+
+    def _find_best_time_step(self, duration, max_steps):
+        """
+        Find the best time interval step for the given duration and maximum steps.
+
+        :param float duration: Total duration in seconds
+        :param int max_steps: Maximum number of major ticks
+        :return: Best step size in seconds
+        """
+        if max_steps < 1:
+            max_steps = 1
+
+        # Calculate the target step size
+        target_step = duration / max_steps
+
+        # Find the time interval that is closest to our target
+        best_step = self.TIME_INTERVALS[0]
+        min_error = abs(target_step - best_step)
+
+        for interval in self.TIME_INTERVALS:
+            error = abs(target_step - interval)
+            if error < min_error:
+                min_error = error
+                best_step = interval
+            # If the interval is getting much larger than target, stop
+            elif interval > target_step * 2:
+                break
+
+        return float(best_step)
+
+    def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
+        """
+        Calculate minor ticks for datetime intervals
+
+        :param list ticks: List of tick arrays
+        :param int maxMinorSteps: Maximum number of minor steps
+        :param float stepSize: Major tick step size
+        """
+        if maxMinorSteps < 1:
+            return
+
+        # For datetime, create intelligent minor tick intervals
+        minor_step = self._get_minor_step(stepSize, maxMinorSteps)
+
+        if minor_step <= 0:
+            return
+
+        major_ticks = ticks[QwtScaleDiv.MajorTick]
+        if len(major_ticks) < 2:
+            return
+
+        minor_ticks = []
+
+        # Generate minor ticks between each pair of major ticks
+        for i in range(len(major_ticks) - 1):
+            start = major_ticks[i]
+            end = major_ticks[i + 1]
+
+            # Add minor ticks between start and end
+            current = start + minor_step
+            while current < end:
+                minor_ticks.append(current)
+                current += minor_step
+
+        ticks[QwtScaleDiv.MinorTick] = minor_ticks
+
+    def _get_minor_step(self, major_step, max_minor_steps):
+        """
+        Calculate appropriate minor tick step size for datetime intervals
+
+        :param float major_step: Major tick step size in seconds
+        :param int max_minor_steps: Maximum number of minor steps
+        :return: Minor tick step size in seconds
+        """
+        # Define sensible minor tick divisions for different time scales
+        if major_step >= 365 * 24 * 60 * 60:  # 1 year or more
+            return 30 * 24 * 60 * 60  # 1 month
+        elif major_step >= 30 * 24 * 60 * 60:  # 1 month or more
+            return 7 * 24 * 60 * 60  # 1 week
+        elif major_step >= 7 * 24 * 60 * 60:  # 1 week or more
+            return 24 * 60 * 60  # 1 day
+        elif major_step >= 24 * 60 * 60:  # 1 day or more
+            return 6 * 60 * 60  # 6 hours
+        elif major_step >= 60 * 60:  # 1 hour or more
+            return 15 * 60  # 15 minutes
+        elif major_step >= 10 * 60:  # 10 minutes or more
+            return 2 * 60  # 2 minutes
+        elif major_step >= 60:  # 1 minute or more
+            return 15  # 15 seconds
+        elif major_step >= 10:  # 10 seconds or more
+            return 2  # 2 seconds
+        else:  # Less than 10 seconds
+            return major_step / max(max_minor_steps, 2)

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/qwt/symbol.py

@@ -1104,8 +1104,7 @@ class QwtSymbol(object):
             painter.scale(ratio, ratio)
             isPinPointEnabled = self.__data.isPinPointEnabled
             self.__data.isPinPointEnabled = False
-            pos = QPointF()
-            self.renderSymbols(painter, pos, 1)
+            self.renderSymbols(painter, [QPointF()])
             self.__data.isPinPointEnabled = isPinPointEnabled
             painter.restore()
 

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/qwt/tests/conftest.py

@@ -13,6 +13,28 @@ from qwt.tests.utils import TestEnvironment
 os.environ[TestEnvironment.UNATTENDED_ENV] = "1"
 
 
+def pytest_addoption(parser):
+    """Add custom command line options to pytest."""
+    # See this StackOverflow answer for more information: https://t.ly/9anqz
+    parser.addoption(
+        "--repeat", action="store", help="Number of times to repeat each test"
+    )
+    parser.addoption(
+        "--show-windows",
+        action="store_true",
+        default=False,
+        help="Display Qt windows during tests (disables QT_QPA_PLATFORM=offscreen)",
+    )
+
+
+def pytest_configure(config):
+    """Configure pytest based on command line options."""
+    if config.option.durations is None:
+        config.option.durations = 10  # Default to showing 10 slowest tests
+    if not config.getoption("--show-windows"):
+        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+
 def pytest_report_header(config):
     """Add additional information to the pytest report header."""
     qtbindings_version = qtpy.PYSIDE_VERSION
@@ -24,14 +46,6 @@ def pytest_report_header(config):
     ]
 
 
-def pytest_addoption(parser):
-    """Add custom command line options to pytest."""
-    # See this StackOverflow answer for more information: https://t.ly/9anqz
-    parser.addoption(
-        "--repeat", action="store", help="Number of times to repeat each test"
-    )
-
-
 def pytest_generate_tests(metafunc):
     """Generate tests for the given metafunc."""
     # See this StackOverflow answer for more information: https://t.ly/9anqz

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/qwt/tests/test_cpudemo.py

@@ -195,7 +195,7 @@ class CpuStat:
         return 100.0 * userDelta / totalDelta, 100.0 * systemDelta / totalDelta
 
     def upTime(self):
-        result = QTime()
+        result = QTime(0, 0, 0)
         for item in self.procValues:
             result = result.addSecs(int(0.01 * item))
         return result

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/qwt/text.py

@@ -333,6 +333,13 @@ class QwtPlainTextEngine(QwtTextEngine):
         :param str text: Text to be rendered
         """
         painter.save()
+
+        # Get and configure font for better rendering of rotated text
+        font = painter.font()
+        # Disable hinting to avoid character misalignment in rotated text
+        font.setHintingPreference(QFont.PreferNoHinting)
+        painter.setFont(font)
+
         qwtUnscaleFont(painter)
         painter.drawText(rect, flags, text)
         painter.restore()

{pythonqwt-0.14.5 → pythonqwt-0.15.0}/qwt/transform.py

@@ -169,7 +169,8 @@ class QwtLogTransform(QwtTransform):
         :param float value: Value to be bounded
         :return: Value modified
         """
-        return np.clip(value, self.LogMin, self.LogMax)
+        bval = np.clip(np.asarray(value, dtype=np.float64), self.LogMin, self.LogMax)
+        return bval.item() if bval.ndim == 0 else bval
 
     def transform(self, value):
         """