Allow read address in SDK (#257)

- Add ``get_watchable_info`` to the client to read detailed metadata of the watchables. 
  - Variable : Address, bitoffset, bitsize
  - Alias : target, target_type, gain, offset, min, max
  - RPV : ID
- ``WatchableHandle`` now have a property to returned the detailed information about the watchables
- Renamed ``display_path`` to ``server_path`` on the client side.
- Renamed ``WatchableConfiguration`` to ``BriefWatchableConfiguration`` and added ``DetailedWatchableConfiguration``
- Cleaned some unit tests

Author: pylessard

.vscode/settings.json

@@ -87,6 +87,7 @@
                 "blaoting" : "bloating",
                 "blaot" : "bloat",
                 "uplaod" : "upload",
+                "sued" : "used",
             }
         }]
 }

scrutiny/gui/components/globals/varlist/varlist_search.py

@@ -27,7 +27,7 @@
 @dataclass(frozen=True, slots=True)
 class SingleResult:
     fqn: str
-    config: sdk.WatchableConfiguration
+    config: sdk.BriefWatchableConfiguration
 
 
 @dataclass(frozen=True, slots=True)
@@ -39,7 +39,7 @@ def match(self, candidate: SingleResult) -> bool:
 
 
 class SearchResultTreeModel(VarListComponentTreeModel):
-    def get_watchable_extra_columns(self, fqn: str, watchable_config: Optional[sdk.WatchableConfiguration] = None) -> List[QStandardItem]:
+    def get_watchable_extra_columns(self, fqn: str, watchable_config: Optional[sdk.BriefWatchableConfiguration] = None) -> List[QStandardItem]:
         outlist: List[QStandardItem] = [QStandardItem(WatchableRegistry.FQN.parse(fqn).path)]
 
         if watchable_config is not None:

scrutiny/gui/components/globals/varlist/varlist_tree_model.py

@@ -19,7 +19,7 @@
     NodeSerializableData
 )
 
-from scrutiny.sdk import WatchableConfiguration
+from scrutiny.sdk import BriefWatchableConfiguration
 from scrutiny.tools.typing import *
 
 
@@ -28,7 +28,7 @@ class VarListComponentTreeModel(WatchableTreeModel):
     Mainly handles drag&drop logic
     """
 
-    def get_watchable_extra_columns(self, fqn: str, watchable_config: Optional[WatchableConfiguration] = None) -> List[QStandardItem]:
+    def get_watchable_extra_columns(self, fqn: str, watchable_config: Optional[BriefWatchableConfiguration] = None) -> List[QStandardItem]:
         """Define the columns to add for a watchable (leaf) row. Called by the parent class"""
         if watchable_config is None:
             return []

scrutiny/gui/components/locals/continuous_graph/continuous_graph_component.py

@@ -877,7 +877,7 @@ def get_x(val: RegistryValueUpdate) -> float:    # A getter to get the relative
             tools.log_exception(self.logger, e, f"Error when receiving data for the chart")
             self.stop_acquisition()
 
-    def _unwatch_callback(self, watcher_id: Union[str, int], server_path: str, watchable_config: sdk.WatchableConfiguration, registry_id: int) -> None:
+    def _unwatch_callback(self, watcher_id: Union[str, int], server_path: str, watchable_config: sdk.BriefWatchableConfiguration, registry_id: int) -> None:
         # Should we do something? User feedback if the watchable is not available anymore maybe?
         pass
 

scrutiny/gui/components/locals/watch/watch_component.py

@@ -281,7 +281,7 @@ def _register_watcher_for_row(self, item: WatchableStandardItem) -> None:
         def update_val_closure(watcher_id: Union[str, int], vals: List[RegistryValueUpdate]) -> None:
             self._update_val_callback(value_item, watcher_id, vals)
 
-        def unwatch_closure(watcher_id: Union[str, int], server_path: str, watchable_config: sdk.WatchableConfiguration, registry_id: int) -> None:
+        def unwatch_closure(watcher_id: Union[str, int], server_path: str, watchable_config: sdk.BriefWatchableConfiguration, registry_id: int) -> None:
             pass
 
         watcher_id = self._get_watcher_id(item)

scrutiny/gui/components/locals/watch/watch_tree_model.py

@@ -22,7 +22,7 @@
 from PySide6.QtGui import (QStandardItem, QPalette, QContextMenuEvent, QDragMoveEvent, QDropEvent,
                            QDragEnterEvent, QKeyEvent, QStandardItem, QAction)
 
-from scrutiny.sdk import WatchableConfiguration, EmbeddedEnum
+from scrutiny.sdk import BriefWatchableConfiguration, EmbeddedEnum
 from scrutiny.gui.core.scrutiny_drag_data import ScrutinyDragData, WatchableListDescriptor
 from scrutiny.gui.core.watchable_registry import WatchableRegistry
 from scrutiny.gui.widgets.watchable_tree import (
@@ -427,7 +427,7 @@ def watchable_item_created(self, item: WatchableStandardItem) -> None:
     def itemFromIndex(self, index: Union[QModelIndex, QPersistentModelIndex]) -> BaseWatchableRegistryTreeStandardItem:
         return cast(BaseWatchableRegistryTreeStandardItem, super().itemFromIndex(index))
 
-    def get_watchable_extra_columns(self, fqn: str = "", watchable_config: Optional[WatchableConfiguration] = None) -> List[QStandardItem]:
+    def get_watchable_extra_columns(self, fqn: str = "", watchable_config: Optional[BriefWatchableConfiguration] = None) -> List[QStandardItem]:
         # We don't use watchable_config here even if we could.
         # We update the value/type when an item is available by calling update_row_state
         return [ValueStandardItem(), DataTypeStandardItem(), EnumNameStandardItem()]
@@ -773,7 +773,7 @@ def set_unavailable(self, arg_item: WatchableStandardItem) -> None:
                 elif isinstance(item, EnumNameStandardItem):
                     item.setText('')
 
-    def set_available(self, arg_item: WatchableStandardItem, watchable_config: WatchableConfiguration) -> None:
+    def set_available(self, arg_item: WatchableStandardItem, watchable_config: BriefWatchableConfiguration) -> None:
         """Make an item in the tree available (normal color)"""
         background_color = self._available_palette.color(QPalette.ColorRole.Base)
         forground_color = self._available_palette.color(QPalette.ColorRole.Text)

scrutiny/gui/core/qt.py

@@ -10,6 +10,7 @@
 __all__ = ['make_qt_app']
 
 from PySide6.QtWidgets import QApplication
+from PySide6.QtCore import QLocale
 from scrutiny.gui.core.threads import QT_THREAD_NAME
 from scrutiny.tools.thread_enforcer import register_thread
 from scrutiny.gui.tools.invoker import CrossThreadInvoker
@@ -18,6 +19,11 @@
 
 def make_qt_app(args: List[str]) -> QApplication:
     register_thread(QT_THREAD_NAME)
+    loc = QLocale.c()   # Forces C-style environment. Decimal points are "."
+    # Prevent showing/interpreting commas as group separator
+    loc.setNumberOptions(QLocale.NumberOption.RejectGroupSeparator | QLocale.NumberOption.OmitGroupSeparator)
+    QLocale.setDefault(loc)
+
     app = QApplication(args)
     CrossThreadInvoker.init()
 

scrutiny/gui/core/server_manager.py

@@ -309,7 +309,7 @@ class _Signals(QObject):    # QObject required for signals to work
     _loaded_sfd: Optional[sdk.SFDInfo]
     """Contains all the info about the actually loaded Scrutiny Firmware Description. ``None`` if not available"""
 
-    _partial_watchable_downloaded_data: Dict[sdk.WatchableType, Dict[str, sdk.WatchableConfiguration]]
+    _partial_watchable_downloaded_data: Dict[sdk.WatchableType, Dict[str, sdk.BriefWatchableConfiguration]]
 
     def __init__(self, watchable_registry: WatchableRegistry, client: Optional[ScrutinyClient] = None) -> None:
         super().__init__()  # Required for signals to work
@@ -544,11 +544,11 @@ def _thread_handle_download_watchable_logic(self) -> None:
                     content = {
                         sdk.WatchableType.RuntimePublishedValue: data.rpv
                     }
-                    invoke_in_qt_thread_synchronized(lambda: self._registry.write_content(content), timeout=2)
+                    invoke_in_qt_thread_synchronized(lambda: self._registry.write_content(content), timeout=5)
                     self._signals.registry_changed.emit()
                 else:
                     invoke_in_qt_thread_synchronized(lambda: self._registry.clear_content_by_type(
-                        [sdk.WatchableType.RuntimePublishedValue]), timeout=2)
+                        [sdk.WatchableType.RuntimePublishedValue]), timeout=3)
                 self._thread_state.runtime_watchables_download_request = None   # Clear the request.
             else:
                 pass  # Downloading
@@ -566,11 +566,11 @@ def _thread_handle_download_watchable_logic(self) -> None:
                         sdk.WatchableType.Variable: data.var,
                         sdk.WatchableType.Alias: data.alias,
                     }
-                    invoke_in_qt_thread_synchronized(lambda: self._registry.write_content(content), timeout=2)
+                    invoke_in_qt_thread_synchronized(lambda: self._registry.write_content(content), timeout=5)
                     self._signals.registry_changed.emit()
                 else:
                     invoke_in_qt_thread_synchronized(lambda: self._registry.clear_content_by_type(
-                        [sdk.WatchableType.Alias, sdk.WatchableType.Variable]), timeout=2)
+                        [sdk.WatchableType.Alias, sdk.WatchableType.Variable]), timeout=3)
                 self._thread_state.sfd_watchables_download_request = None   # Clear the request.
             else:
                 pass    # Downloading
@@ -634,11 +634,11 @@ def clear_func() -> None:
         if ctx.had_data:
             self._signals.registry_changed.emit()
 
-    def _make_var_watchable_from_factories(self, var_factories: Dict[str, sdk.VariableFactoryInterface]) -> Dict[str, sdk.WatchableConfiguration]:
+    def _make_var_watchable_from_factories(self, var_factories: Dict[str, sdk.VariableFactoryInterface]) -> Dict[str, sdk.BriefWatchableConfiguration]:
         """Take the variable factories received from the server and generate all the var watchables from them.
         Might drop some of them to avoid bloating the registry with large buffers 
         """
-        outdict: Dict[str, sdk.WatchableConfiguration] = {}
+        outdict: Dict[str, sdk.BriefWatchableConfiguration] = {}
         var_factories_filt: List[sdk.VariableFactoryInterface] = []
         # Start by removing var factory that generate too many elements
         for access_path, factory in var_factories.items():
@@ -824,15 +824,15 @@ def ui_callback(expected_error: Optional[Exception], unexpected_error: Optional[
             raise NotImplementedError(f"Unsupported state: {registration_status.active_state}")
 
     @enforce_thread(QT_THREAD_NAME)
-    def _qt_registry_watch_callback(self, watcher_id: Union[str, int], server_path: str, watchable_config: sdk.WatchableConfiguration, registry_id: int) -> None:
+    def _qt_registry_watch_callback(self, watcher_id: Union[str, int], server_path: str, watchable_config: sdk.BriefWatchableConfiguration, registry_id: int) -> None:
         """Called when a gui component register a watcher on the registry"""
         # Runs from QT thread
         watcher_count = self._registry.node_watcher_count(watchable_config.watchable_type, server_path)
         if watcher_count is not None and watcher_count > 0:
             self._qt_maybe_request_watch(watchable_config.watchable_type, server_path)
 
     @enforce_thread(QT_THREAD_NAME)
-    def _qt_registry_unwatch_callback(self, watcher_id: Union[str, int], server_path: str, watchable_config: sdk.WatchableConfiguration, registry_id: int) -> None:
+    def _qt_registry_unwatch_callback(self, watcher_id: Union[str, int], server_path: str, watchable_config: sdk.BriefWatchableConfiguration, registry_id: int) -> None:
         """Called when a gui component unregister a watcher on the registry"""
         # Runs from QT thread
         watcher_count = self._registry.node_watcher_count(watchable_config.watchable_type, server_path)

scrutiny/gui/core/watchable_registry.py

@@ -119,20 +119,20 @@ class WatcherNotFoundError(Exception):
 
 
 WatcherValueUpdateCallback = Callable[[WatcherIdType, List[RegistryValueUpdate]], None]
-UnwatchCallback = Callable[[WatcherIdType, str, sdk.WatchableConfiguration, int], None]
-GlobalWatchCallback = Callable[[WatcherIdType, str, sdk.WatchableConfiguration, int], None]
-GlobalUnwatchCallback = Callable[[WatcherIdType, str, sdk.WatchableConfiguration, int], None]
+UnwatchCallback = Callable[[WatcherIdType, str, sdk.BriefWatchableConfiguration, int], None]
+GlobalWatchCallback = Callable[[WatcherIdType, str, sdk.BriefWatchableConfiguration, int], None]
+GlobalUnwatchCallback = Callable[[WatcherIdType, str, sdk.BriefWatchableConfiguration, int], None]
 
 
 @dataclass(init=False, slots=True)
 class WatchableRegistryEntryNode:
     """Leaf node in the tree that is a single watchable"""
-    configuration: sdk.WatchableConfiguration
+    configuration: sdk.BriefWatchableConfiguration
     server_path: str
     registry_id: int
     _watcher_count: int
 
-    def __init__(self, registry: "WatchableRegistry", server_path: str, config: sdk.WatchableConfiguration) -> None:
+    def __init__(self, registry: "WatchableRegistry", server_path: str, config: sdk.BriefWatchableConfiguration) -> None:
         self.server_path = server_path
         self.configuration = config
         self._watcher_count = 0
@@ -244,7 +244,7 @@ def _make_node_id(self) -> int:
         return v
 
     @enforce_thread(QT_THREAD_NAME)
-    def _add_watchable(self, path: str, config: sdk.WatchableConfiguration) -> None:
+    def _add_watchable(self, path: str, config: sdk.BriefWatchableConfiguration) -> None:
         """Adds a single watchable to the tree storage
 
         :param path: Path to add the node to
@@ -654,7 +654,7 @@ def is_watchable_fqn(self, fqn: str) -> bool:
         return isinstance(node, WatchableRegistryEntryNode)
 
     @enforce_thread(QT_THREAD_NAME)
-    def write_content(self, data: Dict[sdk.WatchableType, Dict[str, sdk.WatchableConfiguration]]) -> None:
+    def write_content(self, data: Dict[sdk.WatchableType, Dict[str, sdk.BriefWatchableConfiguration]]) -> None:
         """Write content of the given types.
         Triggers ``changed``.  May trigger ``filled`` if all types have data after calling this function.
 

scrutiny/gui/gui.py

@@ -89,11 +89,6 @@ def __init__(self,
     def run(self, args: List[str]) -> int:
         logger = logging.getLogger(self.__class__.__name__)
 
-        loc = QLocale.c()   # Forces C-style environment. Decimal points are "."
-        # Prevent showing/interpreting commas as group separator
-        loc.setNumberOptions(QLocale.NumberOption.RejectGroupSeparator | QLocale.NumberOption.OmitGroupSeparator)
-        QLocale.setDefault(loc)
-
         if sys.platform == "win32":
             # Tells windows that python process host another application. Enables the QT icon in the task bar
             # see https://stackoverflow.com/questions/1551605/how-to-set-applications-taskbar-icon-in-windows-7