diff --git a/swiftnav_console/advanced_imu_tab.py b/swiftnav_console/advanced_imu_tab.py index 8aec2c9c0..ac98a6432 100644 --- a/swiftnav_console/advanced_imu_tab.py +++ b/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.""" diff --git a/swiftnav_console/advanced_magnetometer_tab.py b/swiftnav_console/advanced_magnetometer_tab.py index 26f3a0bfd..0cd538a7a 100644 --- a/swiftnav_console/advanced_magnetometer_tab.py +++ b/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.""" diff --git a/swiftnav_console/advanced_networking_tab.py b/swiftnav_console/advanced_networking_tab.py index 00e9ebc81..87a1b8b76 100644 --- a/swiftnav_console/advanced_networking_tab.py +++ b/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.""" diff --git a/swiftnav_console/advanced_spectrum_analyzer_tab.py b/swiftnav_console/advanced_spectrum_analyzer_tab.py index 513ccf552..e59522626 100644 --- a/swiftnav_console/advanced_spectrum_analyzer_tab.py +++ b/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.""" diff --git a/swiftnav_console/advanced_system_monitor_tab.py b/swiftnav_console/advanced_system_monitor_tab.py index cffaab953..e6e40aa5d 100644 --- a/swiftnav_console/advanced_system_monitor_tab.py +++ b/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.""" diff --git a/swiftnav_console/baseline_plot.py b/swiftnav_console/baseline_plot.py index 385427a31..b345f3da5 100644 --- a/swiftnav_console/baseline_plot.py +++ b/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.""" diff --git a/swiftnav_console/baseline_table.py b/swiftnav_console/baseline_table.py index d37f78bdb..9fbfb2055 100644 --- a/swiftnav_console/baseline_table.py +++ b/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.""" diff --git a/swiftnav_console/connection.py b/swiftnav_console/connection.py index 7735dcac5..33e144f80 100644 --- a/swiftnav_console/connection.py +++ b/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 diff --git a/swiftnav_console/fusion_status_flags.py b/swiftnav_console/fusion_status_flags.py index 4216cabe8..fee51f8a3 100644 --- a/swiftnav_console/fusion_status_flags.py +++ b/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 diff --git a/swiftnav_console/log_panel.py b/swiftnav_console/log_panel.py index aadd925da..dc82ed5c2 100644 --- a/swiftnav_console/log_panel.py +++ b/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 diff --git a/swiftnav_console/logging_bar.py b/swiftnav_console/logging_bar.py index e959f1382..2f7d9c45f 100644 --- a/swiftnav_console/logging_bar.py +++ b/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 diff --git a/swiftnav_console/observation_tab.py b/swiftnav_console/observation_tab.py index bffff0621..d6ee95734 100644 --- a/swiftnav_console/observation_tab.py +++ b/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]] diff --git a/swiftnav_console/settings_tab.py b/swiftnav_console/settings_tab.py index dc2bb328c..d7d32888c 100644 --- a/swiftnav_console/settings_tab.py +++ b/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 diff --git a/swiftnav_console/solution_position_tab.py b/swiftnav_console/solution_position_tab.py index 102419e65..a51bcad8d 100644 --- a/swiftnav_console/solution_position_tab.py +++ b/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.""" diff --git a/swiftnav_console/solution_table.py b/swiftnav_console/solution_table.py index 7c84a7b64..07f17bd5a 100644 --- a/swiftnav_console/solution_table.py +++ b/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. diff --git a/swiftnav_console/solution_velocity_tab.py b/swiftnav_console/solution_velocity_tab.py index 7b9708743..29fac8094 100644 --- a/swiftnav_console/solution_velocity_tab.py +++ b/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. diff --git a/swiftnav_console/status_bar.py b/swiftnav_console/status_bar.py index 31ad245af..27c64e23b 100644 --- a/swiftnav_console/status_bar.py +++ b/swiftnav_console/status_bar.py @@ -1,7 +1,7 @@ """Status Bar QObjects. """ -from typing import Dict, List, Any +from typing import Dict, Any from PySide2.QtCore import Property, QObject, Signal, Slot @@ -22,9 +22,6 @@ def status_bar_update() -> Dict[str, Any]: } -STATUS_BAR: List[Dict[str, Any]] = [status_bar_update()] - - class StatusBarData(QObject): # pylint: disable=too-many-instance-attributes _pos: str = "" @@ -36,24 +33,23 @@ class StatusBarData(QObject): # pylint: disable=too-many-instance-attributes _solid_connection: bool = False _title: str = "" _antenna_status: str = "" - _data_updated = Signal() + _data_updated = Signal(dict) status_bar: Dict[str, Any] = {} def __init__(self): super().__init__() assert getattr(self.__class__, "_instance", None) is None self.__class__._instance = self - self.status_bar = STATUS_BAR[0] + self.status_bar = status_bar_update() self._data_updated.connect(self.handle_data_updated) @classmethod def post_data_update(cls, update_data: Dict[str, Any]) -> None: - STATUS_BAR[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.status_bar = STATUS_BAR[0] + @Slot(dict) # type: ignore + def handle_data_updated(self, update_data: Dict[str, Any]) -> None: + self.status_bar = update_data def get_pos(self) -> str: return self._pos diff --git a/swiftnav_console/tracking_signals_tab.py b/swiftnav_console/tracking_signals_tab.py index b558f3eb3..cfb1d5acc 100644 --- a/swiftnav_console/tracking_signals_tab.py +++ b/swiftnav_console/tracking_signals_tab.py @@ -19,8 +19,6 @@ def tracking_signals_tab_update() -> Dict[str, Any]: } -TRACKING_SIGNALS_TAB: List[Dict[str, Any]] = [tracking_signals_tab_update()] - # pylint:disable=too-many-instance-attributes class TrackingSignalsPoints(QObject): @@ -37,24 +35,23 @@ class TrackingSignalsPoints(QObject): check_labels_changed = Signal() all_series_changed = Signal() enabled_series_changed = Signal() - _data_updated = Signal() + _data_updated = Signal(dict) _tracking_signals_tab: Dict[str, Any] = {} def __init__(self): super().__init__() assert getattr(self.__class__, "_instance", None) is None self.__class__._instance = self - self._tracking_signals_tab = TRACKING_SIGNALS_TAB[0] + self._tracking_signals_tab = tracking_signals_tab_update() self._data_updated.connect(self.handle_data_updated) @classmethod def post_data_update(cls, update_data: Dict[str, Any]) -> None: - TRACKING_SIGNALS_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._tracking_signals_tab = TRACKING_SIGNALS_TAB[0] + @Slot(dict) # type: ignore + def handle_data_updated(self, update_data: Dict[str, Any]) -> None: + self._tracking_signals_tab = update_data def get_num_labels(self) -> int: # pylint:disable=no-self-use return len(self._tracking_signals_tab[Keys.LABELS]) diff --git a/swiftnav_console/tracking_sky_plot_tab.py b/swiftnav_console/tracking_sky_plot_tab.py index 642a72471..8e65ca0cc 100644 --- a/swiftnav_console/tracking_sky_plot_tab.py +++ b/swiftnav_console/tracking_sky_plot_tab.py @@ -16,14 +16,11 @@ def tracking_sky_plot_update() -> Dict[str, Any]: } -TRACKING_SKY_PLOT_TAB: List[Dict[str, Any]] = [tracking_sky_plot_update()] - - class TrackingSkyPlotPoints(QObject): _labels: List[List[str]] = [] _all_series: List[QtCharts.QXYSeries] = [] - _data_updated = Signal() + _data_updated = Signal(dict) labels_changed = Signal() all_series_changed = Signal() _tracking_sky_plot: Dict[str, Any] = {} @@ -32,17 +29,16 @@ def __init__(self): super().__init__() assert getattr(self.__class__, "_instance", None) is None self.__class__._instance = self - self._tracking_sky_plot = TRACKING_SKY_PLOT_TAB[0] + self._tracking_sky_plot = tracking_sky_plot_update() self._data_updated.connect(self.handle_data_updated) @classmethod def post_data_update(cls, update_data: Dict[str, Any]) -> None: - TRACKING_SKY_PLOT_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._tracking_sky_plot = TRACKING_SKY_PLOT_TAB[0] + @Slot(dict) # type: ignore + def handle_data_updated(self, update_data: Dict[str, Any]) -> None: + self._tracking_sky_plot = update_data def get_labels(self) -> List[List[str]]: # pylint:disable=no-self-use return self._tracking_sky_plot[Keys.LABELS] diff --git a/swiftnav_console/update_tab.py b/swiftnav_console/update_tab.py index e236661d2..62cd60be2 100644 --- a/swiftnav_console/update_tab.py +++ b/swiftnav_console/update_tab.py @@ -1,7 +1,7 @@ """Status Bar QObjects. """ -from typing import Any, Dict, List +from typing import Any, Dict from PySide2.QtCore import Property, QObject, Signal, Slot @@ -29,9 +29,6 @@ def update_tab_update() -> Dict[str, Any]: } -UPDATE_TAB: List[Dict[str, Any]] = [update_tab_update()] - - class UpdateTabData(QObject): # pylint: disable=too-many-instance-attributes,too-many-public-methods _hardware_revision: str = "" @@ -50,24 +47,23 @@ class UpdateTabData(QObject): # pylint: disable=too-many-instance-attributes,to _console_outdated: bool = False _console_version_current: str = "" _console_version_latest: str = "" - _data_updated: Signal = Signal() + _data_updated: Signal = Signal(dict) update_tab: Dict[str, Any] = {} def __init__(self): super().__init__() assert getattr(self.__class__, "_instance", None) is None self.__class__._instance = self - self.update_tab = UPDATE_TAB[0] + self.update_tab = update_tab_update() self._data_updated.connect(self.handle_data_updated) @classmethod def post_data_update(cls, update_data: Dict[str, Any]) -> None: - UPDATE_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.update_tab = UPDATE_TAB[0] + @Slot(dict) # type: ignore + def handle_data_updated(self, update_data: Dict[str, Any]) -> None: + self.update_tab = update_data def get_hardware_revision(self) -> str: return self._hardware_revision