PythonQwt 0.14.6__tar.gz → 0.15.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.14.6
+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.6 → pythonqwt-0.15.0/PythonQwt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PythonQwt
-Version: 0.14.6
+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.6 → 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.6 → 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.6 → 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.6"
+__version__ = "0.15.0"
 QWT_VERSION_STR = "6.1.5"
 
 

{pythonqwt-0.14.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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()