Remaining QObjects and types fixes.

Author: john-michaelburke

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

swiftnav_console/log_panel.py

@@ -18,31 +18,27 @@ def log_panel_update() -> Dict[str, Any]:
     }
 
 
-LOG_PANEL: List[Dict[str, Any]] = [log_panel_update()]
-
-
 class LogPanelData(QObject):
     _entries: List[Dict[str, str]] = []
     _log_level_labels: List[str] = []
     _log_level: str
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     log_panel: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.log_panel = LOG_PANEL[0]
+        self.log_panel = log_panel_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        LOG_PANEL[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.log_panel = LOG_PANEL[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.log_panel = update_data
 
     def get_log_level_labels(self) -> List[str]:
         return self._log_level_labels

swiftnav_console/logging_bar.py

@@ -40,7 +40,9 @@ class LoggingBarData(QObject):  # pylint: disable=too-many-instance-attributes
     _recording_duration_sec: int = 0
     _recording_size: float = 0
     _recording_filename: str = ""
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
+    _recording_updated = Signal(dict)
+
     logging_bar: Dict[str, Any] = {}
     logging_bar_recording: Dict[str, Any] = {}
 
@@ -51,21 +53,23 @@ def __init__(self):
         self.logging_bar = logging_bar_update()
         self.logging_bar_recording = logging_bar_recording_update()
         self._data_updated.connect(self.handle_data_updated)
+        self._recording_updated.connect(self.handle_recording_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        LOGGING_BAR[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
     @classmethod
     def post_recording_data_update(cls, update_data: Dict[str, Any]) -> None:
-        LOGGING_BAR_RECORDING[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._recording_updated.emit(update_data)
+
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.logging_bar = update_data
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.logging_bar = LOGGING_BAR[0]
-        self.logging_bar_recording = LOGGING_BAR_RECORDING[0]
+    @Slot(dict)  # type: ignore
+    def handle_recording_updated(self, update_data: Dict[str, Any]) -> None:
+        self.logging_bar_recording = update_data
 
     def get_csv_logging(self) -> bool:
         return self._csv_logging

swiftnav_console/observation_tab.py

@@ -50,10 +50,6 @@ def observation_update() -> Dict[str, Any]:
     }
 
 
-REMOTE_OBSERVATION_TAB: List[Dict[str, Any]] = [observation_update()]
-LOCAL_OBSERVATION_TAB: List[Dict[str, Any]] = [observation_update()]
-
-
 class ObservationTableModel(QAbstractTableModel):  # pylint: disable=too-many-public-methods
     # pylint: disable=too-many-instance-attributes
     # Might want to move the column_widths logic into QML and use QML's
@@ -66,7 +62,7 @@ class ObservationTableModel(QAbstractTableModel):  # pylint: disable=too-many-pu
     show_gps_only_changed = Signal(bool, arguments="show_gps_only")
     codes_changed = Signal()
     dataPopulated = Signal()
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     _observation_tab: Dict[str, Any] = {}
 
     column_metadata = [
@@ -101,18 +97,11 @@ def __init__(self, parent=None):
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        if cls._instance.get_remote():
-            REMOTE_OBSERVATION_TAB[0] = update_data
-        else:
-            LOCAL_OBSERVATION_TAB[0] = update_data
-        cls._instance._data_updated.emit()  # pylint: disable=protected-access
+        cls._instance._data_updated.emit(update_data)  # pylint: disable=protected-access
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        if self._remote:
-            self._observation_tab = REMOTE_OBSERVATION_TAB[0]
-        else:
-            self._observation_tab = LOCAL_OBSERVATION_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self._observation_tab = update_data
 
     def get_codes(self) -> List[List[str]]:
         return [entry["prn"].code for entry in self._observation_tab[Keys.ROWS]]

swiftnav_console/settings_tab.py

@@ -21,19 +21,15 @@ def settings_table_update() -> Dict[str, Any]:
     }
 
 
-SETTINGS_IMPORT_STATUS: List[str] = [""]
-SETTINGS_INS: List[Dict[str, Any]] = [settings_ins_update()]
-SETTINGS_NOTIFICATION: List[str] = [""]
-SETTINGS_TABLE: List[Dict[str, Any]] = [settings_table_update()]
-
-
 class SettingsTabData(QObject):
 
     _import_status: str = ""
     _recommended_ins_settings: List[List[Any]] = []
     _new_ins_confirmation: bool = False
     _notification: str = ""
-    _data_updated = Signal()
+    _import_status_updated = Signal(str)
+    _ins_updated = Signal(dict)
+    _notification_updated = Signal(str)
     settings_import_status: str = ""
     settings_ins: Dict[str, Any] = {}
     settings_notification: str = ""
@@ -42,31 +38,36 @@ def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.settings_import_status = SETTINGS_IMPORT_STATUS[0]
-        self.settings_ins = SETTINGS_INS[0]
-        self.settings_notification = SETTINGS_NOTIFICATION[0]
-        self._data_updated.connect(self.handle_data_updated)
+        self.settings_import_status = ""
+        self.settings_ins = settings_ins_update()
+        self.settings_notification = ""
+        self._import_status_updated.connect(self.handle_import_status_updated)
+        self._ins_updated.connect(self.handle_ins_updated)
+        self._notification_updated.connect(self.handle_notification_updated)
 
     @classmethod
     def post_import_status_update(cls, update_data: str) -> None:
-        SETTINGS_IMPORT_STATUS[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._import_status_updated.emit(update_data)
 
     @classmethod
     def post_ins_update(cls, update_data: Dict[str, Any]) -> None:
-        SETTINGS_INS[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._ins_updated.emit(update_data)
 
     @classmethod
     def post_notification_update(cls, update_data: str) -> None:
-        SETTINGS_NOTIFICATION[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._notification_updated.emit(update_data)
+
+    @Slot(str)  # type: ignore
+    def handle_import_status_updated(self, data: str) -> None:
+        self.settings_import_status = data
+
+    @Slot(dict)  # type: ignore
+    def handle_ins_updated(self, update_data: Dict[str, Any]) -> None:
+        self.settings_ins = update_data
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.settings_import_status = SETTINGS_IMPORT_STATUS[0]
-        self.settings_ins = SETTINGS_INS[0]
-        self.settings_notification = SETTINGS_NOTIFICATION[0]
+    @Slot(str)  # type: ignore
+    def handle_notification_updated(self, data: str) -> None:
+        self.settings_notification = data
 
     def get_import_status(self) -> str:
         return self._import_status
@@ -129,24 +130,23 @@ def clear_new_ins_confirmation(self, cp: SettingsTabData) -> SettingsTabData:  #
 class SettingsTableEntries(QObject):
 
     _entries: List[dict] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     settings_table: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.settings_table = SETTINGS_TABLE[0]
+        self.settings_table = settings_table_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        SETTINGS_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.settings_table = SETTINGS_TABLE[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.settings_table = update_data
 
     def get_entries(self) -> List[dict]:
         return self._entries

swiftnav_console/solution_position_tab.py

@@ -20,9 +20,6 @@ def solution_position_update() -> Dict[str, Any]:
     }
 
 
-SOLUTION_POSITION_TAB: List[Dict[str, Any]] = [solution_position_update()]
-
-
 class SolutionPositionPoints(QObject):  # pylint: disable=too-many-instance-attributes,too-many-public-methods
 
     _points: List[List[QPointF]] = [[]]
@@ -32,24 +29,23 @@ class SolutionPositionPoints(QObject):  # pylint: disable=too-many-instance-attr
     _lon_min: float = 0.0
     _lon_max: float = 0.0
     _available_units: List[str] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     solution_position: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.solution_position = SOLUTION_POSITION_TAB[0]
+        self.solution_position = solution_position_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        SOLUTION_POSITION_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.solution_position = SOLUTION_POSITION_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.solution_position = update_data
 
     def get_lat_min(self) -> float:
         """Getter for _lat_min."""

swiftnav_console/solution_table.py

@@ -21,24 +21,23 @@ class SolutionTableEntries(QObject):
 
     _entries: List[List[str]] = []
     _valid: bool = False
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     solution_table: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.solution_table = SOLUTION_TABLE[0]
+        self.solution_table = solution_table_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        SOLUTION_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.solution_table = SOLUTION_TABLE[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.solution_table = update_data
 
     def get_valid(self) -> bool:
         """Getter for _valid.

swiftnav_console/solution_velocity_tab.py

@@ -18,9 +18,6 @@ def solution_velocity_update() -> Dict[str, Any]:
     }
 
 
-SOLUTION_VELOCITY_TAB: List[Dict[str, Any]] = [solution_velocity_update()]
-
-
 class SolutionVelocityPoints(QObject):
 
     _colors: List[str] = []
@@ -29,24 +26,23 @@ class SolutionVelocityPoints(QObject):
     _min: float = 0.0
     _max: float = 0.0
     _available_units: List[str] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     solution_velocity: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.solution_velocity = SOLUTION_VELOCITY_TAB[0]
+        self.solution_velocity = solution_velocity_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        SOLUTION_VELOCITY_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.solution_velocity = SOLUTION_VELOCITY_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.solution_velocity = update_data
 
     def get_valid(self) -> bool:
         """Getter for _valid.