Convert all python globals to signal.emit updates[CPP-695]

swiftnav_console/advanced_imu_tab.py

@@ -15,31 +15,27 @@ def advanced_imu_tab_update() -> Dict[str, Any]:
     }
 
 
-ADVANCED_IMU_TAB: List[Dict[str, Any]] = [advanced_imu_tab_update()]
-
-
 class AdvancedImuPoints(QObject):
 
     _points: List[List[QPointF]] = [[]]
     _fields_data: List[float] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     advanced_imu_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.advanced_imu_tab = ADVANCED_IMU_TAB[0]
+        self.advanced_imu_tab = advanced_imu_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        ADVANCED_IMU_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.advanced_imu_tab = ADVANCED_IMU_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.advanced_imu_tab = update_data
 
     def get_fields_data(self) -> List[float]:
         """Getter for _fields_data."""

swiftnav_console/advanced_magnetometer_tab.py

@@ -16,32 +16,28 @@ def advanced_magnetometer_tab_update() -> Dict[str, Any]:
     }
 
 
-ADVANCED_MAGNETOMETER_TAB: List[Dict[str, Any]] = [advanced_magnetometer_tab_update()]
-
-
 class AdvancedMagnetometerPoints(QObject):
 
     _points: List[List[QPointF]] = [[]]
     _ymin: float = 0.0
     _ymax: float = 0.0
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     advanced_magnetometer_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.advanced_magnetometer_tab = ADVANCED_MAGNETOMETER_TAB[0]
+        self.advanced_magnetometer_tab = advanced_magnetometer_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        ADVANCED_MAGNETOMETER_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.advanced_magnetometer_tab = ADVANCED_MAGNETOMETER_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.advanced_magnetometer_tab = update_data
 
     def get_ymin(self) -> float:
         """Getter for _ymin."""

swiftnav_console/advanced_networking_tab.py

@@ -17,32 +17,28 @@ def advanced_networking_tab_update() -> Dict[str, Any]:
     }
 
 
-ADVANCED_NETWORKING_TAB: List[Dict[str, Any]] = [advanced_networking_tab_update()]
-
-
 class AdvancedNetworkingData(QObject):
     _network_info: List[List[str]] = []
     _running: bool = False
     _ip_address: str = ""
     _port: int = 0
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     advanced_networking_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.advanced_networking_tab = ADVANCED_NETWORKING_TAB[0]
+        self.advanced_networking_tab = advanced_networking_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        ADVANCED_NETWORKING_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.advanced_networking_tab = ADVANCED_NETWORKING_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.advanced_networking_tab = update_data
 
     def get_network_info(self) -> List[List[str]]:
         """Getter for _network_info."""

swiftnav_console/advanced_spectrum_analyzer_tab.py

@@ -20,9 +20,6 @@ def advanced_spectrum_analyzer_tab_update() -> Dict[str, Any]:
     }
 
 
-ADVANCED_SPECTRUM_ANALYZER_TAB: List[Dict[str, Any]] = [advanced_spectrum_analyzer_tab_update()]
-
-
 class AdvancedSpectrumAnalyzerPoints(QObject):
 
     _points: List[QPointF] = []
@@ -31,24 +28,23 @@ class AdvancedSpectrumAnalyzerPoints(QObject):
     _xmin: float = 0.0
     _xmax: float = 0.0
     _channel: int = 0
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     advanced_spectrum_analyzer_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.advanced_spectrum_analyzer_tab = ADVANCED_SPECTRUM_ANALYZER_TAB[0]
+        self.advanced_spectrum_analyzer_tab = advanced_spectrum_analyzer_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        ADVANCED_SPECTRUM_ANALYZER_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.advanced_spectrum_analyzer_tab = ADVANCED_SPECTRUM_ANALYZER_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.advanced_spectrum_analyzer_tab = update_data
 
     def get_ymin(self) -> float:
         """Getter for _ymin."""

swiftnav_console/advanced_system_monitor_tab.py

@@ -20,9 +20,6 @@ def advanced_system_monitor_tab_update() -> Dict[str, Any]:
     }
 
 
-ADVANCED_SYSTEM_MONITOR_TAB: List[Dict[str, Any]] = [advanced_system_monitor_tab_update()]
-
-
 class AdvancedSystemMonitorData(QObject):  # pylint: disable=too-many-instance-attributes
     _obs_period: List[List[Any]] = []
     _obs_latency: List[List[Any]] = []
@@ -31,24 +28,23 @@ class AdvancedSystemMonitorData(QObject):  # pylint: disable=too-many-instance-a
     _zynq_temp: float = 0.0
     _fe_temp: float = 0.0
     _csac_received: bool = False
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     advanced_system_monitor_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.advanced_system_monitor_tab = ADVANCED_SYSTEM_MONITOR_TAB[0]
+        self.advanced_system_monitor_tab = advanced_system_monitor_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        ADVANCED_SYSTEM_MONITOR_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.advanced_system_monitor_tab = ADVANCED_SYSTEM_MONITOR_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.advanced_system_monitor_tab = update_data
 
     def get_csac_telem_list(self) -> List[List[str]]:
         """Getter for _csac_telem_list."""

swiftnav_console/baseline_plot.py

@@ -19,9 +19,6 @@ def baseline_plot_update() -> Dict[str, Any]:
     }
 
 
-BASELINE_PLOT: List[Dict[str, Any]] = [baseline_plot_update()]
-
-
 class BaselinePlotPoints(QObject):
 
     _points: List[List[QPointF]] = [[]]
@@ -30,24 +27,23 @@ class BaselinePlotPoints(QObject):
     _n_max: float = 0.0
     _e_min: float = 0.0
     _e_max: float = 0.0
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     baseline_plot: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.baseline_plot = BASELINE_PLOT[0]
+        self.baseline_plot = baseline_plot_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        BASELINE_PLOT[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.baseline_plot = BASELINE_PLOT[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.baseline_plot = update_data
 
     def get_n_min(self) -> float:
         """Getter for _n_min."""

swiftnav_console/baseline_table.py

@@ -14,30 +14,26 @@ def baseline_table_update() -> Dict[str, Any]:
     }
 
 
-BASELINE_TABLE: List[Dict[str, Any]] = [baseline_table_update()]
-
-
 class BaselineTableEntries(QObject):
 
     _entries: List[List[str]] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     baseline_table: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.baseline_table = BASELINE_TABLE[0]
+        self.baseline_table = baseline_table_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        BASELINE_TABLE[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.baseline_table = BASELINE_TABLE[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.baseline_table = update_data
 
     def get_entries(self) -> List[List[str]]:
         """Getter for _entries."""

swiftnav_console/connection.py

@@ -23,11 +23,6 @@ def connection_update() -> Dict[str, Any]:
     }
 
 
-CONNECTION: List[Dict[str, Any]] = [connection_update()]
-CONNECTION_STATE: List[ConnectionState] = [ConnectionState.DISCONNECTED]
-CONNECTION_MESSAGE: List[str] = [""]
-
-
 class ConnectionData(QObject):  # pylint: disable=too-many-instance-attributes disable=too-many-public-methods
 
     _available_ports: List[str] = []
@@ -43,7 +38,9 @@ class ConnectionData(QObject):  # pylint: disable=too-many-instance-attributes d
     _console_version: str = ""
     _previous_connection_type: ConnectionType = ConnectionType.Serial
     _connection_message: str = ""
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
+    _state_updated = Signal(ConnectionState)
+    _message_updated = Signal(str)
     connection: Dict[str, Any] = {}
     connection_state: ConnectionState = ConnectionState.DISCONNECTED
     connection_msg: str = ""
@@ -52,31 +49,36 @@ def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.connection = CONNECTION[0]
-        self.connection_state = CONNECTION_STATE[0]
-        self.connection_msg = CONNECTION_MESSAGE[0]
+        self.connection = connection_update()
+        self.connection_state = ConnectionState.DISCONNECTED
+        self.connection_msg = ""
         self._data_updated.connect(self.handle_data_updated)
+        self._state_updated.connect(self.handle_state_updated)
+        self._message_updated.connect(self.handle_message_updated)
 
     @classmethod
     def post_connection_state_update(cls, update_data: ConnectionState) -> None:
-        CONNECTION_STATE[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._state_updated.emit(update_data)
 
     @classmethod
     def post_connection_message_update(cls, update_data: str) -> None:
-        CONNECTION_MESSAGE[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._message_updated.emit(update_data)
 
     @classmethod
     def post_connection_data_update(cls, update_data: Dict[str, Any]) -> None:
-        CONNECTION[0] = update_data
-        cls._instance._data_updated.emit()
-
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.connection_state = CONNECTION_STATE[0]
-        self.connection_msg = CONNECTION_MESSAGE[0]
-        self.connection = CONNECTION[0]
+        cls._instance._data_updated.emit(update_data)
+
+    @Slot(ConnectionState)  # type: ignore
+    def handle_state_updated(self, data: ConnectionState) -> None:
+        self.connection_state = data
+
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.connection = update_data
+
+    @Slot(str)  # type: ignore
+    def handle_message_updated(self, data: str) -> None:
+        self.connection_msg = data
 
     def get_available_ports(self) -> List[str]:
         return self._available_ports

swiftnav_console/fusion_status_flags.py

@@ -1,7 +1,7 @@
 """Fusion Status Bar QObjects.
 """
 
-from typing import Dict, Any, List
+from typing import Dict, Any
 
 from PySide2.QtCore import Property, QObject, Signal, Slot
 
@@ -19,9 +19,6 @@ def fusion_status_flags_update() -> Dict[str, Any]:
     }
 
 
-FUSION_STATUS_FLAGS: List[Dict[str, Any]] = [fusion_status_flags_update()]
-
-
 class FusionStatusFlagsData(QObject):
 
     _gnsspos: str = FusionStatus.UNKNOWN
@@ -30,7 +27,7 @@ class FusionStatusFlagsData(QObject):
     _speed: str = FusionStatus.UNKNOWN
     _nhc: str = FusionStatus.UNKNOWN
     _zerovel: str = FusionStatus.UNKNOWN
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     fusion_status_flags: Dict[str, Any] = {}
 
     def __init__(self):
@@ -42,12 +39,11 @@ def __init__(self):
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        FUSION_STATUS_FLAGS[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.fusion_status_flags = FUSION_STATUS_FLAGS[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.fusion_status_flags = update_data
 
     def get_gnsspos(self) -> str:
         return self._gnsspos