Merge branch 'master' into shell_cmd_update

Author: nstelter-slac

examples/datetime/datetime.ui

@@ -6,7 +6,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>208</width>
+    <width>240</width>
     <height>149</height>
    </rect>
   </property>

pydm/data_plugins/plugin.py

@@ -2,6 +2,7 @@
 import numpy as np
 import weakref
 import threading
+import warnings
 
 from typing import Optional, Callable
 from urllib.parse import ParseResult
@@ -105,103 +106,106 @@ def remove_listener(self, channel, destroying: Optional[bool] = False) -> None:
             QObject is destroyed, setting this to True ensures we do not try to do the disconnection a second time.
             If set to False, any active signals/slots on the channel will be manually disconnected here.
         """
-        if self._should_disconnect(channel.connection_slot, destroying):
-            try:
-                self.connection_state_signal.disconnect(channel.connection_slot)
-            except TypeError:
-                pass
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=RuntimeWarning)
 
-        if self._should_disconnect(channel.value_slot, destroying):
-            for signal_type in (int, float, str, bool, object):
+            if self._should_disconnect(channel.connection_slot, destroying):
                 try:
-                    self.new_value_signal[signal_type].disconnect(channel.value_slot)
-                # If the signal exists (always does in this case since we define it for all 'signal_type' earlier)
-                # but doesn't match slot, TypeError is thrown. We also don't need to catch KeyError/IndexError here,
-                # since those are only thrown when signal type doesn't exist.
+                    self.connection_state_signal.disconnect(channel.connection_slot)
                 except TypeError:
                     pass
 
-        if self._should_disconnect(channel.severity_slot, destroying):
-            try:
-                self.new_severity_signal.disconnect(channel.severity_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.write_access_slot, destroying):
-            try:
-                self.write_access_signal.disconnect(channel.write_access_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.enum_strings_slot, destroying):
-            try:
-                self.enum_strings_signal.disconnect(channel.enum_strings_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.unit_slot, destroying):
-            try:
-                self.unit_signal.disconnect(channel.unit_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.upper_ctrl_limit_slot, destroying):
-            try:
-                self.upper_ctrl_limit_signal.disconnect(channel.upper_ctrl_limit_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.lower_ctrl_limit_slot, destroying):
-            try:
-                self.lower_ctrl_limit_signal.disconnect(channel.lower_ctrl_limit_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.upper_alarm_limit_slot, destroying):
-            try:
-                self.upper_alarm_limit_signal.disconnect(channel.upper_alarm_limit_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.lower_alarm_limit_slot, destroying):
-            try:
-                self.lower_alarm_limit_signal.disconnect(channel.lower_alarm_limit_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.upper_warning_limit_slot, destroying):
-            try:
-                self.upper_warning_limit_signal.disconnect(channel.upper_warning_limit_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.lower_warning_limit_slot, destroying):
-            try:
-                self.lower_warning_limit_signal.disconnect(channel.lower_warning_limit_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.prec_slot, destroying):
-            try:
-                self.prec_signal.disconnect(channel.prec_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if self._should_disconnect(channel.timestamp_slot, destroying):
-            try:
-                self.timestamp_signal.disconnect(channel.timestamp_slot)
-            except (KeyError, TypeError):
-                pass
-
-        if not destroying and channel.value_signal is not None and hasattr(self, "put_value"):
-            for signal_type in (str, int, float, np.ndarray, dict):
+            if self._should_disconnect(channel.value_slot, destroying):
+                for signal_type in (int, float, str, bool, object):
+                    try:
+                        self.new_value_signal[signal_type].disconnect(channel.value_slot)
+                    # If the signal exists (always does in this case since we define it for all 'signal_type' earlier)
+                    # but doesn't match slot, TypeError is thrown. We also don't need to catch KeyError/IndexError here,
+                    # since those are only thrown when signal type doesn't exist.
+                    except TypeError:
+                        pass
+
+            if self._should_disconnect(channel.severity_slot, destroying):
+                try:
+                    self.new_severity_signal.disconnect(channel.severity_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if self._should_disconnect(channel.write_access_slot, destroying):
                 try:
-                    channel.value_signal[signal_type].disconnect(self.put_value)
-                # When signal type can't be found, PyQt5 throws KeyError here, but PySide6 index error.
-                # If signal type exists but doesn't match the slot, TypeError gets thrown.
-                except (KeyError, IndexError, TypeError):
+                    self.write_access_signal.disconnect(channel.write_access_slot)
+                except (KeyError, TypeError):
                     pass
 
+            if self._should_disconnect(channel.enum_strings_slot, destroying):
+                try:
+                    self.enum_strings_signal.disconnect(channel.enum_strings_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if self._should_disconnect(channel.unit_slot, destroying):
+                try:
+                    self.unit_signal.disconnect(channel.unit_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if self._should_disconnect(channel.upper_ctrl_limit_slot, destroying):
+                try:
+                    self.upper_ctrl_limit_signal.disconnect(channel.upper_ctrl_limit_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if self._should_disconnect(channel.lower_ctrl_limit_slot, destroying):
+                try:
+                    self.lower_ctrl_limit_signal.disconnect(channel.lower_ctrl_limit_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if self._should_disconnect(channel.upper_alarm_limit_slot, destroying):
+                try:
+                    self.upper_alarm_limit_signal.disconnect(channel.upper_alarm_limit_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if self._should_disconnect(channel.lower_alarm_limit_slot, destroying):
+                try:
+                    self.lower_alarm_limit_signal.disconnect(channel.lower_alarm_limit_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if self._should_disconnect(channel.upper_warning_limit_slot, destroying):
+                try:
+                    self.upper_warning_limit_signal.disconnect(channel.upper_warning_limit_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if self._should_disconnect(channel.lower_warning_limit_slot, destroying):
+                try:
+                    self.lower_warning_limit_signal.disconnect(channel.lower_warning_limit_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if self._should_disconnect(channel.prec_slot, destroying):
+                try:
+                    self.prec_signal.disconnect(channel.prec_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if self._should_disconnect(channel.timestamp_slot, destroying):
+                try:
+                    self.timestamp_signal.disconnect(channel.timestamp_slot)
+                except (KeyError, TypeError):
+                    pass
+
+            if not destroying and channel.value_signal is not None and hasattr(self, "put_value"):
+                for signal_type in (str, int, float, np.ndarray, dict):
+                    try:
+                        channel.value_signal[signal_type].disconnect(self.put_value)
+                    # When signal type can't be found, PyQt5 throws KeyError here, but PySide6 index error.
+                    # If signal type exists but doesn't match the slot, TypeError gets thrown.
+                    except (KeyError, IndexError, TypeError):
+                        pass
+
         self.listener_count = self.listener_count - 1
         if self.listener_count < 1:
             self.close()

pydm/main_window.py

@@ -377,10 +377,9 @@ def change_stylesheet_action(self, checked):
             self, "Change Stylesheet...", folder, "PyDM Stylesheets (*.qss *.css)"
         )
 
-        if ss_filename:
-            ss_filename = str(ss_filename)
-            self.ss_path = ss_filename.split("'")
-            style = open(self.ss_path[1], "r")
+        ss_path = str(ss_filename[0])
+        if ss_path:
+            style = open(ss_path, "r")
             style = style.read()
             self.setStyleSheet(style)
 

pydm/tests/widgets/test_base.py

@@ -218,7 +218,12 @@ def mock_exec_(*args):
     monkeypatch.setattr(QMenu, "exec_", mock_exec_)
 
     mouse_event = QMouseEvent(
-        QMouseEvent.MouseButtonRelease, pydm_label.rect().center(), Qt.RightButton, Qt.RightButton, Qt.ShiftModifier
+        QMouseEvent.MouseButtonRelease,
+        pydm_label.rect().center(),  # localPos
+        pydm_label.rect().center(),  # globalPos
+        Qt.RightButton,  # button
+        Qt.RightButton,  # buttons
+        Qt.ShiftModifier,  # modifiers
     )
     pydm_label.open_context_menu(mouse_event)
     assert "Context Menu displayed." in caplog.text

pydm/tests/widgets/test_datetime_edit.py

@@ -0,0 +1,104 @@
+# Unit Tests for the PyDMLineEdit Widget
+
+import os
+import platform
+import pytest
+import time
+
+from pydm.widgets.datetime import PyDMDateTimeEdit, TimeBase
+from qtpy.QtCore import QDateTime
+
+
+# --------------------
+# POSITIVE TEST CASES
+# --------------------
+
+
+@pytest.mark.parametrize(
+    "init_channel",
+    [
+        "CA://MTEST",
+        "",
+        None,
+    ],
+)
+def test_construct(qtbot, init_channel):
+    """
+    Test the widget construct.
+    Expectations:
+    All parameters have the correct default value.
+
+    Parameters
+    ----------
+     qtbot : fixture
+        Window for widget testing
+    init_channel : str
+        The data channel to be used by the widget
+
+    """
+    pydm_datetimeedit = PyDMDateTimeEdit(init_channel=init_channel)
+    qtbot.addWidget(pydm_datetimeedit)
+
+    if init_channel:
+        assert pydm_datetimeedit.channel == str(init_channel)
+    else:
+        assert pydm_datetimeedit.channel is None
+
+    assert pydm_datetimeedit.blockPastDate == True
+    assert pydm_datetimeedit.relative == True
+    assert pydm_datetimeedit.timeBase == TimeBase.Milliseconds
+
+
+@pytest.mark.parametrize(
+    "value, expected_value",
+    [
+        # Assuming the time is localized to EST
+        (0, "1969/12/31 19:00:00.000"),
+        (1000, "1969/12/31 19:00:01.000"),
+        (60000, "1969/12/31 19:01:00.000"),
+        (3600000, "1969/12/31 20:00:00.000"),
+        (18000000, "1970/01/01 00:00:00.000"),
+        (0.0, "1969/12/31 19:00:00.000"),
+        (1000.0, "1969/12/31 19:00:01.000"),
+        (60000.0, "1969/12/31 19:01:00.000"),
+        (3600000.0, "1969/12/31 20:00:00.000"),
+        (18000000.0, "1970/01/01 00:00:00.000"),
+    ],
+)
+def test_value_changed(qtbot, signals, value, expected_value):
+    """
+    Test the widget's handling of the value changed event.
+
+    Expectations:
+    The following settings are in place after the value changed signal is emitted:
+    1. The value displayed by the widget is the new value
+    2. The value format maintained by the widget the correct format for the new value
+
+    Parameters
+    ----------
+    qtbot : fixture
+        pytest-qt window for widget testing
+    signals : fixture
+        The signals fixture, which provides access signals to be bound to the appropriate slots
+    value : int, float
+        The value to be displayed by the widget
+    expected_value : str
+        The expected displayed value of the widget
+    """
+    # These tests will fail on Windows, we can't easily modify time
+    if platform.system() == "Windows":
+        return
+
+    os.environ["TZ"] = "US/Eastern"
+    time.tzset()
+
+    pydm_datetimeedit = PyDMDateTimeEdit()
+    pydm_datetimeedit.blockPastDate = False
+    pydm_datetimeedit.relative = False
+    pydm_datetimeedit.timeBase = TimeBase.Milliseconds
+    qtbot.addWidget(pydm_datetimeedit)
+
+    signals.new_value_signal[type(value)].connect(pydm_datetimeedit.channelValueChanged)
+    signals.new_value_signal[type(value)].emit(value)
+
+    assert pydm_datetimeedit.text() == expected_value