nova-trame 0.23.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

nova/trame/_internal/utils.py

@@ -0,0 +1,30 @@
+"""Internal utilities for nova-trame."""
+
+from typing import Any, Tuple, Union
+
+from trame_server.core import State
+
+from nova.mvvm._internal.utils import rgetdictvalue, rsetdictvalue
+
+
+# Reads a state parameter from Trame. For internal use only, if you're using this in your application you're violating
+# the MVVM framework. :)
+def get_state_param(state: State, value: Union[Any, Tuple]) -> Any:
+    if isinstance(value, tuple):
+        return rgetdictvalue(state, value[0])
+
+    return value
+
+
+# Writes a state parameter to Trame. For internal use only, if you're using this in your application you're violating
+# the MVVM framework. :)
+def set_state_param(state: State, value: Union[Any, Tuple], new_value: Any = None) -> Any:
+    with state:
+        if isinstance(value, tuple):
+            if new_value is not None:
+                rsetdictvalue(state, value[0], new_value)
+            elif len(value) > 1:
+                rsetdictvalue(state, value[0], value[1])
+            state.dirty(value[0].split(".")[0])
+
+    return get_state_param(state, value)

nova/trame/model/data_selector.py

@@ -12,20 +12,23 @@ class DataSelectorState(BaseModel, validate_assignment=True):
     """Selection state for identifying datafiles."""
 
     directory: str = Field(default="")
-    subdirectory: str = Field(default="")
     extensions: List[str] = Field(default=[])
-    prefix: str = Field(default="")
+    subdirectory: str = Field(default="")
 
 
 class DataSelectorModel:
     """Manages file system interactions for the DataSelector widget."""
 
-    def __init__(self, state: DataSelectorState, directory: str, extensions: List[str], prefix: str) -> None:
+    def __init__(self, state: DataSelectorState) -> None:
         self.state: DataSelectorState = state
 
-        self.state.directory = directory
-        self.state.extensions = extensions
-        self.state.prefix = prefix
+    def set_binding_parameters(self, **kwargs: Any) -> None:
+        if "directory" in kwargs:
+            self.state.directory = kwargs["directory"]
+        if "extensions" in kwargs:
+            self.state.extensions = kwargs["extensions"]
+        if "subdirectory" in kwargs:
+            self.state.subdirectory = kwargs["subdirectory"]
 
     def sort_directories(self, directories: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         # Sort the current level of dictionaries
@@ -47,6 +50,10 @@ class DataSelectorModel:
 
                 if len(path_parts) > 1:
                     dirs.clear()
+                elif path_parts != ["."]:
+                    # Subdirectories are fully queried upon being opened, so we only need to query one item to determine
+                    # if the target directory has any children.
+                    dirs[:] = dirs[:1]
 
                 # Only create a new entry for top-level directories
                 if len(path_parts) == 1 and path_parts[0] != ".":  # This indicates a top-level directory
@@ -85,10 +92,7 @@ class DataSelectorModel:
     def get_datafiles_from_path(self, base_path: Path) -> List[str]:
         datafiles = []
         try:
-            if self.state.prefix:
-                datafile_path = base_path / self.state.prefix
-            else:
-                datafile_path = base_path / self.state.subdirectory
+            datafile_path = base_path / self.state.subdirectory
 
             for entry in os.scandir(datafile_path):
                 if entry.is_file():

nova/trame/model/ornl/neutron_data_selector.py

@@ -107,23 +107,21 @@ class NeutronDataSelectorState(DataSelectorState):
 class NeutronDataSelectorModel(DataSelectorModel):
     """Manages file system interactions for the DataSelector widget."""
 
-    def __init__(
-        self,
-        state: NeutronDataSelectorState,
-        facility: str,
-        instrument: str,
-        extensions: List[str],
-        prefix: str,
-        allow_custom_directories: bool,
-    ) -> None:
-        super().__init__(state, "", extensions, prefix)
+    def __init__(self, state: NeutronDataSelectorState) -> None:
+        super().__init__(state)
         self.state: NeutronDataSelectorState = state
 
-        self.state.facility = facility
-        self.state.instrument = instrument
-        self.state.extensions = extensions
-        self.state.prefix = prefix
-        self.state.allow_custom_directories = allow_custom_directories
+    def set_binding_parameters(self, **kwargs: Any) -> None:
+        super().set_binding_parameters(**kwargs)
+
+        if "facility" in kwargs:
+            self.state.facility = kwargs["facility"]
+        if "instrument" in kwargs:
+            self.state.instrument = kwargs["instrument"]
+        if "experiment" in kwargs:
+            self.state.experiment = kwargs["experiment"]
+        if "allow_custom_directories" in kwargs:
+            self.state.allow_custom_directories = kwargs["allow_custom_directories"]
 
     def get_facilities(self) -> List[str]:
         return natsorted(self.state.get_facilities())
@@ -183,11 +181,3 @@ class NeutronDataSelectorModel(DataSelectorModel):
             return []
 
         return self.get_datafiles_from_path(base_path)
-
-    def set_state(self, facility: Optional[str], instrument: Optional[str], experiment: Optional[str]) -> None:
-        if facility is not None:
-            self.state.facility = facility
-        if instrument is not None:
-            self.state.instrument = instrument
-        if experiment is not None:
-            self.state.experiment = experiment

nova/trame/view/components/data_selector.py

@@ -1,14 +1,19 @@
 """View Implementation for DataSelector."""
 
-from typing import Any, List, Optional, cast
+from asyncio import ensure_future, sleep
+from typing import Any, List, Tuple, Union, cast
+from warnings import warn
 
 from trame.app import get_server
 from trame.widgets import client, datagrid, html
 from trame.widgets import vuetify3 as vuetify
+from trame_server.core import State
 
+from nova.mvvm._internal.utils import rgetdictvalue
 from nova.mvvm.trame_binding import TrameBinding
+from nova.trame._internal.utils import get_state_param, set_state_param
 from nova.trame.model.data_selector import DataSelectorModel, DataSelectorState
-from nova.trame.view.layouts import GridLayout, VBoxLayout
+from nova.trame.view.layouts import GridLayout, HBoxLayout, VBoxLayout
 from nova.trame.view_model.data_selector import DataSelectorViewModel
 
 from .input_field import InputField
@@ -21,29 +26,36 @@ class DataSelector(datagrid.VGrid):
 
     def __init__(
         self,
-        v_model: str,
-        directory: str,
-        extensions: Optional[List[str]] = None,
-        prefix: str = "",
-        select_strategy: str = "all",
+        v_model: Union[str, Tuple],
+        directory: Union[str, Tuple],
+        extensions: Union[List[str], Tuple, None] = None,
+        prefix: Union[str, Tuple] = "",
+        subdirectory: Union[str, Tuple] = "",
+        refresh_rate: Union[int, Tuple] = 30,
+        select_strategy: Union[str, Tuple] = "all",
         **kwargs: Any,
     ) -> None:
         """Constructor for DataSelector.
 
         Parameters
         ----------
-        v_model : str
+        v_model : Union[str, Tuple]
             The name of the state variable to bind to this widget. The state variable will contain a list of the files
             selected by the user.
-        directory : str
+        directory : Union[str, Tuple]
             The top-level folder to expose to users. Only contents of this directory and its children will be exposed to
             users.
-        extensions : List[str], optional
+        extensions : Union[List[str], Tuple], optional
             A list of file extensions to restrict selection to. If unset, then all files will be shown.
-        prefix : str, optional
-            A subdirectory within the selected top-level folder to show files. If not specified, the user will be shown
-            a folder browser and will be able to see all files in the selected top-level folder.
-        select_strategy : str, optional
+        prefix : Union[str, Tuple], optional
+            Deprecated. Please refer to the `subdirectory` parameter.
+        subdirectory : Union[str, Tuple], optional
+            A subdirectory within the selected top-level folder to show files. If not specified as a string, the user
+            will be shown a folder browser and will be able to see all files in the selected top-level folder.
+        refresh_rate : Union[int, Tuple], optional
+            The number of seconds between attempts to automatically refresh the file list. Set to zero to disable this
+            feature. Defaults to 30 seconds.
+        select_strategy : Union[str, Tuple], optional
             The selection strategy to pass to the `VDataTable component <https://trame.readthedocs.io/en/latest/trame.widgets.vuetify3.html#trame.widgets.vuetify3.VDataTable>`__.
             If unset, the `all` strategy will be used.
         **kwargs
@@ -68,11 +80,29 @@ class DataSelector(datagrid.VGrid):
         else:
             self._label = None
 
+        if prefix:
+            warn(
+                "The prefix parameter has been deprecated. Please switch to using the subdirectory parameter.",
+                category=DeprecationWarning,
+                stacklevel=1,
+            )
+
+            if not subdirectory:
+                subdirectory = prefix
+
         self._v_model = v_model
-        self._v_model_name_in_state = v_model.split(".")[0]
+        if isinstance(v_model, str):
+            self._v_model_name_in_state = v_model.split(".")[0]
+        else:
+            self._v_model_name_in_state = v_model[0].split(".")[0]
+
         self._directory = directory
+        self._last_directory = get_state_param(self.state, self._directory)
         self._extensions = extensions if extensions is not None else []
-        self._prefix = prefix
+        self._last_extensions = get_state_param(self.state, self._extensions)
+        self._subdirectory = subdirectory
+        self._last_subdirectory = get_state_param(self.state, self._subdirectory)
+        self._refresh_rate = refresh_rate
         self._select_strategy = select_strategy
 
         self._revogrid_id = f"nova__dataselector_{self._next_id}_rv"
@@ -86,17 +116,30 @@ class DataSelector(datagrid.VGrid):
         ).exec
         self._reset_state = client.JSEval(exec=f"{self._v_model} = []; {self._flush_state}").exec
 
-        self.create_model()
-        self.create_viewmodel()
+        self._create_model()
+        self._create_viewmodel()
+        self._setup_bindings()
 
         self.create_ui(**kwargs)
 
+        ensure_future(self._refresh_loop())
+
+    @property
+    def state(self) -> State:
+        return get_server(None, client_type="vue3").state
+
     def create_ui(self, *args: Any, **kwargs: Any) -> None:
         with VBoxLayout(classes="nova-data-selector", height="100%") as self._layout:
-            self._layout.filter = html.Div()
+            with HBoxLayout(valign="center"):
+                self._layout.filter = html.Div(classes="flex-1-1")
+                with vuetify.VBtn(
+                    classes="mx-1", density="compact", icon=True, variant="text", click=self.refresh_contents
+                ):
+                    vuetify.VIcon("mdi-refresh")
+                    vuetify.VTooltip("Refresh Contents", activator="parent")
 
             with GridLayout(columns=2, classes="flex-1-0 h-0", valign="start"):
-                if not self._prefix:
+                if isinstance(self._subdirectory, tuple) or not self._subdirectory:
                     with html.Div(classes="d-flex flex-column h-100 overflow-hidden"):
                         vuetify.VListSubheader("Available Directories", classes="flex-0-1 justify-center px-0")
                         vuetify.VTreeview(
@@ -108,7 +151,7 @@ class DataSelector(datagrid.VGrid):
                             item_value="path",
                             items=(self._directories_name,),
                             click_open=(self._vm.expand_directory, "[$event.path]"),
-                            update_activated=(self._vm.set_subdirectory, "$event"),
+                            update_activated=(self.set_subdirectory, "$event"),
                         )
                         vuetify.VListItem("No directories found", classes="flex-0-1 text-center", v_else=True)
 
@@ -125,6 +168,7 @@ class DataSelector(datagrid.VGrid):
                         "    prop: 'title',"
                         "}]",
                     ),
+                    column_span=1 if isinstance(self._subdirectory, tuple) or not self._subdirectory else 2,
                     frame_size=10,
                     hide_attribution=True,
                     id=self._revogrid_id,
@@ -169,11 +213,11 @@ class DataSelector(datagrid.VGrid):
                         f"(+{{{{ {self._v_model}.length - 2 }}}} others)", v_if="index === 2", classes="text-caption"
                     )
 
-    def create_model(self) -> None:
+    def _create_model(self) -> None:
         state = DataSelectorState()
-        self._model = DataSelectorModel(state, self._directory, self._extensions, self._prefix)
+        self._model = DataSelectorModel(state)
 
-    def create_viewmodel(self) -> None:
+    def _create_viewmodel(self) -> None:
         server = get_server(None, client_type="vue3")
         binding = TrameBinding(server.state)
 
@@ -183,14 +227,93 @@ class DataSelector(datagrid.VGrid):
         self._vm.datafiles_bind.connect(self._datafiles_name)
         self._vm.reset_bind.connect(self.reset)
 
-        self._vm.update_view()
+    def refresh_contents(self) -> None:
+        self._vm.update_view(refresh_directories=True)
 
     def reset(self, _: Any = None) -> None:
         self._reset_state()
         self._reset_rv_grid()
 
+    def set_subdirectory(self, subdirectory_path: str = "") -> None:
+        set_state_param(self.state, self._subdirectory, subdirectory_path)
+        self._vm.set_subdirectory(subdirectory_path)
+
     def set_state(self, *args: Any, **kwargs: Any) -> None:
         raise TypeError(
             "The old DataSelector component has been renamed to NeutronDataSelector. Please import it from "
             "`nova.trame.view.components.ornl`."
         )
+
+    # This method sets up Trame state change listeners for each binding parameter that can be changed directly by this
+    # component. This allows us to communicate the changes to the developer's bindings without requiring our own. We
+    # don't want bindings in the internal implementation as our callbacks could compete with the developer's.
+    def _setup_bindings(self) -> None:
+        # If the bindings were given initial values, write these to the state.
+        set_state_param(self.state, self._directory)
+        set_state_param(self.state, self._extensions)
+        set_state_param(self.state, self._subdirectory)
+        self._vm.set_binding_parameters(
+            directory=get_state_param(self.state, self._directory),
+            extensions=get_state_param(self.state, self._extensions),
+            subdirectory=get_state_param(self.state, self._subdirectory),
+        )
+
+        # The component used by this parameter will attempt to set the initial value itself, which will trigger the
+        # below change listeners causing unpredictable behavior.
+        if isinstance(self._subdirectory, tuple):
+            self._subdirectory = (self._subdirectory[0],)
+
+        # Now we set up the change listeners for all bound parameters. These are responsible for updating the component
+        # when other portions of the application manipulate these parameters.
+        if isinstance(self._directory, tuple):
+
+            @self.state.change(self._directory[0].split(".")[0])
+            def on_directory_change(**kwargs: Any) -> None:
+                directory = rgetdictvalue(kwargs, self._directory[0])
+                if directory != self._last_directory:
+                    self._last_directory = directory
+                    self._vm.set_binding_parameters(
+                        directory=set_state_param(self.state, self._directory, directory),
+                    )
+
+        if isinstance(self._extensions, tuple):
+
+            @self.state.change(self._extensions[0].split(".")[0])
+            def on_extensions_change(**kwargs: Any) -> None:
+                extensions = rgetdictvalue(kwargs, self._extensions[0])
+                if extensions != self._last_extensions:
+                    self._last_extensions = extensions
+                    self._vm.set_binding_parameters(
+                        extensions=set_state_param(self.state, self._extensions, extensions),
+                    )
+
+        if isinstance(self._subdirectory, tuple):
+
+            @self.state.change(self._subdirectory[0].split(".")[0])
+            def on_subdirectory_change(**kwargs: Any) -> None:
+                subdirectory = rgetdictvalue(kwargs, self._subdirectory[0])
+                if subdirectory != self._last_subdirectory:
+                    self._last_subdirectory = subdirectory
+                    self._vm.set_binding_parameters(
+                        subdirectory=set_state_param(self.state, self._subdirectory, subdirectory),
+                    )
+
+    async def _refresh_loop(self) -> None:
+        refresh_rate: int = set_state_param(self.state, self._refresh_rate)
+        skip = False
+
+        if refresh_rate > 0:
+            while True:
+                await sleep(refresh_rate)
+                if skip:
+                    continue
+
+                self.refresh_contents()
+                self.state.dirty(self._datafiles_name)
+
+                try:
+                    refresh_rate = int(get_state_param(self.state, self._refresh_rate))
+                    skip = False
+                except TypeError:
+                    refresh_rate = 1
+                    skip = True

nova/trame/view/components/ornl/neutron_data_selector.py

@@ -1,11 +1,12 @@
 """View Implementation for DataSelector."""
 
-from typing import Any, List, Optional
+from typing import Any, List, Tuple, Union
 from warnings import warn
 
 from trame.app import get_server
 from trame.widgets import vuetify3 as vuetify
 
+from nova.mvvm._internal.utils import rgetdictvalue
 from nova.mvvm.trame_binding import TrameBinding
 from nova.trame.model.ornl.neutron_data_selector import (
     CUSTOM_DIRECTORIES_LABEL,
@@ -15,7 +16,7 @@ from nova.trame.model.ornl.neutron_data_selector import (
 from nova.trame.view.layouts import GridLayout
 from nova.trame.view_model.ornl.neutron_data_selector import NeutronDataSelectorViewModel
 
-from ..data_selector import DataSelector
+from ..data_selector import DataSelector, get_state_param, set_state_param
 from ..input_field import InputField
 
 vuetify.enable_lab()
@@ -26,35 +27,42 @@ class NeutronDataSelector(DataSelector):
 
     def __init__(
         self,
-        v_model: str,
-        allow_custom_directories: bool = False,
-        facility: str = "",
-        instrument: str = "",
-        extensions: Optional[List[str]] = None,
-        prefix: str = "",
-        select_strategy: str = "all",
+        v_model: Union[str, Tuple],
+        allow_custom_directories: Union[bool, Tuple] = False,
+        facility: Union[str, Tuple] = "",
+        instrument: Union[str, Tuple] = "",
+        experiment: Union[str, Tuple] = "",
+        extensions: Union[List[str], Tuple, None] = None,
+        subdirectory: Union[str, Tuple] = "",
+        refresh_rate: Union[int, Tuple] = 30,
+        select_strategy: Union[str, Tuple] = "all",
         **kwargs: Any,
     ) -> None:
         """Constructor for DataSelector.
 
         Parameters
         ----------
-        v_model : str
+        v_model : Union[str, Tuple]
             The name of the state variable to bind to this widget. The state variable will contain a list of the files
             selected by the user.
-        allow_custom_directories : bool, optional
+        allow_custom_directories : Union[bool, Tuple], optional
             Whether or not to allow users to provide their own directories to search for datafiles in. Ignored if the
             facility parameter is set.
-        facility : str, optional
+        facility : Union[str, Tuple], optional
             The facility to restrict data selection to. Options: HFIR, SNS
-        instrument : str, optional
+        instrument : Union[str, Tuple], optional
             The instrument to restrict data selection to. Please use the instrument acronym (e.g. CG-2).
-        extensions : List[str], optional
+        experiment : Union[str, Tuple], optional
+            The experiment to restrict data selection to.
+        extensions : Union[List[str], Tuple], optional
             A list of file extensions to restrict selection to. If unset, then all files will be shown.
-        prefix : str, optional
-            A subdirectory within the user's chosen experiment to show files. If not specified, the user will be shown a
-            folder browser and will be able to see all files in the experiment that they have access to.
-        select_strategy : str, optional
+        subdirectory : Union[str, Tuple], optional
+            A subdirectory within the user's chosen experiment to show files. If not specified as a string, the user
+            will be shown a folder browser and will be able to see all files in the experiment that they have access to.
+        refresh_rate : Union[str, Tuple], optional
+            The number of seconds between attempts to automatically refresh the file list. Set to zero to disable this
+            feature. Defaults to 30 seconds.
+        select_strategy : Union[str, Tuple], optional
             The selection strategy to pass to the `VDataTable component <https://trame.readthedocs.io/en/latest/trame.widgets.vuetify3.html#trame.widgets.vuetify3.VDataTable>`__.
             If unset, the `all` strategy will be used.
         **kwargs
@@ -65,53 +73,76 @@ class NeutronDataSelector(DataSelector):
         -------
         None
         """
-        if facility and allow_custom_directories:
-            warn("allow_custom_directories will be ignored since the facility parameter is set.", stacklevel=1)
+        if isinstance(facility, str) and allow_custom_directories:
+            warn("allow_custom_directories will be ignored since the facility parameter is fixed.", stacklevel=1)
 
         self._facility = facility
         self._instrument = instrument
+        self._experiment = experiment
         self._allow_custom_directories = allow_custom_directories
+        self._last_allow_custom_directories = self._allow_custom_directories
 
+        self._state_name = f"nova__dataselector_{self._next_id}_state"
         self._facilities_name = f"nova__neutrondataselector_{self._next_id}_facilities"
+        self._selected_facility_name = (
+            self._facility[0] if isinstance(self._facility, tuple) else f"{self._state_name}.facility"
+        )
         self._instruments_name = f"nova__neutrondataselector_{self._next_id}_instruments"
+        self._selected_instrument_name = (
+            self._instrument[0] if isinstance(self._instrument, tuple) else f"{self._state_name}.instrument"
+        )
         self._experiments_name = f"nova__neutrondataselector_{self._next_id}_experiments"
+        self._selected_experiment_name = (
+            self._experiment[0] if isinstance(self._experiment, tuple) else f"{self._state_name}.experiment"
+        )
 
-        super().__init__(v_model, "", extensions, prefix, select_strategy, **kwargs)
+        super().__init__(
+            v_model,
+            "",
+            extensions=extensions,
+            subdirectory=subdirectory,
+            refresh_rate=refresh_rate,
+            select_strategy=select_strategy,
+            **kwargs,
+        )
 
     def create_ui(self, **kwargs: Any) -> None:
         super().create_ui(**kwargs)
         with self._layout.filter:
             with GridLayout(columns=3):
                 columns = 3
-                if self._facility == "":
+                if isinstance(self._facility, tuple) or not self._facility:
                     columns -= 1
                     InputField(
-                        v_model=f"{self._state_name}.facility", items=(self._facilities_name,), type="autocomplete"
+                        v_model=self._selected_facility_name,
+                        items=(self._facilities_name,),
+                        type="autocomplete",
+                        update_modelValue=(self.update_facility, "[$event]"),
                     )
-                if self._instrument == "":
+                if isinstance(self._instrument, tuple) or not self._instrument:
                     columns -= 1
                     InputField(
-                        v_if=f"{self._state_name}.facility !== '{CUSTOM_DIRECTORIES_LABEL}'",
-                        v_model=f"{self._state_name}.instrument",
+                        v_if=f"{self._selected_facility_name} !== '{CUSTOM_DIRECTORIES_LABEL}'",
+                        v_model=self._selected_instrument_name,
                         items=(self._instruments_name,),
                         type="autocomplete",
+                        update_modelValue=(self.update_instrument, "[$event]"),
                     )
                 InputField(
-                    v_if=f"{self._state_name}.facility !== '{CUSTOM_DIRECTORIES_LABEL}'",
-                    v_model=f"{self._state_name}.experiment",
+                    v_if=f"{self._selected_facility_name} !== '{CUSTOM_DIRECTORIES_LABEL}'",
+                    v_model=self._selected_experiment_name,
                     column_span=columns,
                     items=(self._experiments_name,),
                     type="autocomplete",
+                    update_modelValue=(self.update_experiment, "[$event]"),
                 )
                 InputField(v_else=True, v_model=f"{self._state_name}.custom_directory", column_span=2)
 
-    def create_model(self) -> None:
+    def _create_model(self) -> None:
         state = NeutronDataSelectorState()
-        self._model: NeutronDataSelectorModel = NeutronDataSelectorModel(
-            state, self._facility, self._instrument, self._extensions, self._prefix, self._allow_custom_directories
-        )
+        self._model: NeutronDataSelectorModel = NeutronDataSelectorModel(state)
 
-    def create_viewmodel(self) -> None:
+    def _create_viewmodel(self) -> None:
         server = get_server(None, client_type="vue3")
         binding = TrameBinding(server.state)
 
@@ -126,26 +157,94 @@ class NeutronDataSelector(DataSelector):
 
         self._vm.update_view()
 
-    def set_state(
-        self, facility: Optional[str] = None, instrument: Optional[str] = None, experiment: Optional[str] = None
-    ) -> None:
-        """Programmatically set the facility, instrument, and/or experiment to restrict data selection to.
+    # This method sets up Trame state change listeners for each binding parameter that can be changed directly by this
+    # component. This allows us to communicate the changes to the developer's bindings without requiring our own. We
+    # don't want bindings in the internal implementation as our callbacks could compete with the developer's.
+    def _setup_bindings(self) -> None:
+        # If the bindings were given initial values, write these to the state.
+        set_state_param(self.state, self._facility)
+        set_state_param(self.state, self._instrument)
+        set_state_param(self.state, self._experiment)
+        set_state_param(self.state, self._allow_custom_directories)
+        self._last_facility = get_state_param(self.state, self._facility)
+        self._last_instrument = get_state_param(self.state, self._instrument)
+        self._last_experiment = get_state_param(self.state, self._experiment)
+        self._vm.set_binding_parameters(
+            facility=get_state_param(self.state, self._facility),
+            instrument=get_state_param(self.state, self._instrument),
+            experiment=get_state_param(self.state, self._experiment),
+            allow_custom_directories=get_state_param(self.state, self._allow_custom_directories),
+        )
 
-        If a parameter is None, then it will not be updated.
+        # Now we set up the change listeners for all bound parameters. These are responsible for updating the component
+        # when other portions of the application manipulate these parameters.
+        if isinstance(self._facility, tuple):
+
+            @self.state.change(self._facility[0].split(".")[0])
+            def on_facility_change(**kwargs: Any) -> None:
+                facility = rgetdictvalue(kwargs, self._facility[0])
+                if facility != self._last_facility:
+                    self._last_facility = facility
+                    self._vm.set_binding_parameters(
+                        facility=set_state_param(self.state, (self._selected_facility_name,), facility)
+                    )
+                    self._vm.reset()
 
-        Parameters
-        ----------
-        facility : str, optional
-            The facility to restrict data selection to. Options: HFIR, SNS
-        instrument : str, optional
-            The instrument to restrict data selection to. Must be at the selected facility.
-        experiment : str, optional
-            The experiment to restrict data selection to. Must begin with "IPTS-". It is your responsibility to validate
-            that the provided experiment exists within the instrument directory. If it doesn't then no datafiles will be
-            shown to the user.
+        if isinstance(self._instrument, tuple):
 
-        Returns
-        -------
-        None
-        """
-        self._vm.set_state(facility, instrument, experiment)
+            @self.state.change(self._instrument[0].split(".")[0])
+            def on_instrument_change(**kwargs: Any) -> None:
+                instrument = rgetdictvalue(kwargs, self._instrument[0])
+                if instrument != self._last_instrument:
+                    self._last_instrument = instrument
+                    self._vm.set_binding_parameters(
+                        instrument=set_state_param(self.state, (self._selected_instrument_name,), instrument)
+                    )
+                    self._vm.reset()
+
+        if isinstance(self._experiment, tuple):
+
+            @self.state.change(self._experiment[0].split(".")[0])
+            def on_experiment_change(**kwargs: Any) -> None:
+                experiment = rgetdictvalue(kwargs, self._experiment[0])
+                if experiment != self._last_experiment:
+                    self._last_experiment = experiment
+                    self._vm.set_binding_parameters(
+                        experiment=set_state_param(self.state, (self._selected_experiment_name,), experiment)
+                    )
+                    self._vm.reset()
+
+        if isinstance(self._allow_custom_directories, tuple):
+
+            @self.state.change(self._allow_custom_directories[0].split(".")[0])
+            def on_allow_custom_directories_change(**kwargs: Any) -> None:
+                allow_custom_directories = rgetdictvalue(kwargs, self._allow_custom_directories[0])  # type: ignore
+                if allow_custom_directories != self._last_allow_custom_directories:
+                    self._last_allow_custom_directories = allow_custom_directories
+                    self._vm.set_binding_parameters(
+                        allow_custom_directories=set_state_param(
+                            self.state, self._allow_custom_directories, allow_custom_directories
+                        )
+                    )
+
+    # These update methods notify the rest of the application when the component changes bound parameters.
+    def update_facility(self, facility: str) -> None:
+        self._vm.set_binding_parameters(
+            facility=set_state_param(self.state, (self._selected_facility_name,), facility),
+            instrument=set_state_param(self.state, (self._selected_instrument_name,), ""),  # Reset the instrument
+            experiment=set_state_param(self.state, (self._selected_experiment_name,), ""),  # Reset the experiment
+        )
+        self._vm.reset()
+
+    def update_instrument(self, instrument: str) -> None:
+        self._vm.set_binding_parameters(
+            instrument=set_state_param(self.state, (self._selected_instrument_name,), instrument),
+            experiment=set_state_param(self.state, (self._selected_experiment_name,), ""),  # Reset the experiment
+        )
+        self._vm.reset()
+
+    def update_experiment(self, experiment: str) -> None:
+        self._vm.set_binding_parameters(
+            experiment=set_state_param(self.state, (self._selected_experiment_name,), experiment),
+        )
+        self._vm.reset()

nova/trame/view_model/data_selector.py

@@ -16,7 +16,7 @@ class DataSelectorViewModel:
 
         self.datafiles: List[Dict[str, Any]] = []
         self.directories: List[Dict[str, Any]] = []
-        self.expanded: List[str] = []
+        self.expanded: Dict[str, List[str]] = {}
 
         self.state_bind = binding.new_bind(self.model.state, callback_after_update=self.on_state_updated)
         self.directories_bind = binding.new_bind()
@@ -44,20 +44,32 @@ class DataSelectorViewModel:
         current_level["children"] = new_directories
 
         # Mark this directory as expanded and display the new content
-        self.expanded.append(paths[-1])
+        self.expanded[paths[-1]] = paths
         self.directories_bind.update_in_view(self.directories)
 
+    def reexpand_directories(self) -> None:
+        paths_to_expand = self.expanded.values()
+        self.expanded = {}
+
+        for paths in paths_to_expand:
+            self.expand_directory(paths)
+
     def on_state_updated(self, results: Dict[str, Any]) -> None:
         pass
 
+    def set_binding_parameters(self, **kwargs: Any) -> None:
+        self.model.set_binding_parameters(**kwargs)
+        self.update_view(refresh_directories=True)
+
     def set_subdirectory(self, subdirectory_path: str = "") -> None:
         self.model.set_subdirectory(subdirectory_path)
         self.update_view()
 
-    def update_view(self) -> None:
+    def update_view(self, refresh_directories: bool = False) -> None:
         self.state_bind.update_in_view(self.model.state)
-        if not self.directories:
+        if not self.directories or refresh_directories:
             self.directories = self.model.get_directories()
+            self.reexpand_directories()
         self.directories_bind.update_in_view(self.directories)
 
         self.datafiles = [

nova/trame/view_model/ornl/neutron_data_selector.py

@@ -1,6 +1,6 @@
 """View model implementation for the DataSelector widget."""
 
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
 from nova.mvvm.interface import BindingInterface
 from nova.trame.model.ornl.neutron_data_selector import NeutronDataSelectorModel
@@ -18,34 +18,22 @@ class NeutronDataSelectorViewModel(DataSelectorViewModel):
         self.instruments_bind = binding.new_bind()
         self.experiments_bind = binding.new_bind()
 
-    def set_state(self, facility: Optional[str], instrument: Optional[str], experiment: Optional[str]) -> None:
-        self.model.set_state(facility, instrument, experiment)
-        self.update_view()
-
     def reset(self) -> None:
         self.model.set_subdirectory("")
         self.directories = self.model.get_directories()
-        self.expanded = []
+        self.expanded = {}
         self.reset_bind.update_in_view(None)
 
     def on_state_updated(self, results: Dict[str, Any]) -> None:
         for update in results.get("updated", []):
             match update:
-                case "facility":
-                    self.model.set_state(facility=None, instrument="", experiment="")
-                    self.reset()
-                case "instrument":
-                    self.model.set_state(facility=None, instrument=None, experiment="")
-                    self.reset()
-                case "experiment":
-                    self.reset()
                 case "custom_directory":
                     self.reset()
-        self.update_view()
+                    self.update_view()
 
-    def update_view(self) -> None:
+    def update_view(self, refresh_directories: bool = False) -> None:
         self.facilities_bind.update_in_view(self.model.get_facilities())
         self.instruments_bind.update_in_view(self.model.get_instruments())
         self.experiments_bind.update_in_view(self.model.get_experiments())
 
-        super().update_view()
+        super().update_view(refresh_directories)

{nova_trame-0.23.0.dist-info → nova_trame-0.24.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nova-trame
-Version: 0.23.0
+Version: 0.24.0
 Summary: A Python Package for injecting curated themes and custom components into Trame applications
 License: MIT
 Keywords: NDIP,Python,Trame,Vuetify

{nova_trame-0.23.0.dist-info → nova_trame-0.24.0.dist-info}/RECORD

@@ -1,15 +1,16 @@
 nova/__init__.py,sha256=ED6jHcYiuYpr_0vjGz0zx2lrrmJT9sDJCzIljoDfmlM,65
 nova/trame/__init__.py,sha256=gFrAg1qva5PIqR5TjvPzAxLx103IKipJLqp3XXvrQL8,59
-nova/trame/model/data_selector.py,sha256=jXu2tRmk0sI6fSbBs-bSggEiRw99M5d8NwpvPOk9nDs,4182
-nova/trame/model/ornl/neutron_data_selector.py,sha256=nfjXwT93JcPjJwyDynoP_stDVAfjUs7neeVZTk_04gc,6424
+nova/trame/_internal/utils.py,sha256=Yi6zdHfeIHE5dQXmxZ9x0Yyuwkjn2geFoXAYtZ_PO2s,1060
+nova/trame/model/data_selector.py,sha256=rDmWDtHVGgi5e2fBEYvChM2vVKNu798m67Sq8MUN2UI,4463
+nova/trame/model/ornl/neutron_data_selector.py,sha256=Eu-CnX4Gr_T-Kz_l3SsMhyGf61hlHhRCYpcn7em7TCk,6168
 nova/trame/model/remote_file_input.py,sha256=9KAf31ZHzpsh_aXUrNcF81Q5jvUZDWCzW1QATKls-Jk,3675
 nova/trame/view/components/__init__.py,sha256=60BeS69aOrFnkptjuD17rfPE1f4Z35iBH56TRmW5MW8,451
-nova/trame/view/components/data_selector.py,sha256=uahrLdTRKrec-g8L-xIYW0OG_dCnFuKJxq69ROf2c6I,8532
+nova/trame/view/components/data_selector.py,sha256=EJ8fYCrkhRgDExAcewiUb7jTs7Qzo-GKVYWx7oFlrT0,14592
 nova/trame/view/components/execution_buttons.py,sha256=fIkrWKI3jFZqk3GHhtmYh3nK2c-HOXpD3D3zd_TUpi0,4049
 nova/trame/view/components/file_upload.py,sha256=7VcpfA6zmiqMDLkwVPlb35Tf0IUTBN1xsHpoUFnSr1w,3111
 nova/trame/view/components/input_field.py,sha256=q6WQ_N-BOlimUL9zgazDlsDfK28FrrKjH4he8e_HzRA,16088
 nova/trame/view/components/ornl/__init__.py,sha256=HnxzzSsxw0vQSDCVFfWsAxx1n3HnU37LMuQkfiewmSU,90
-nova/trame/view/components/ornl/neutron_data_selector.py,sha256=RZAowBxRaxlVsHTsukHTX0reveWG1K6ib8zb1kKL9Ow,6631
+nova/trame/view/components/ornl/neutron_data_selector.py,sha256=YTYuLD5eDn3AsKguT8ksPx2Yme2RxheuXQGlhuTLOOc,12527
 nova/trame/view/components/progress_bar.py,sha256=fCfPw4MPAvORaeFOXugreok4GLpDVZGMkqvnv-AhMxg,2967
 nova/trame/view/components/remote_file_input.py,sha256=ByrBFj8svyWezcardCWrS_4Ag3fgTYNg_11lDW1FIA8,9669
 nova/trame/view/components/tool_outputs.py,sha256=-6pDURd2l_FK_8EWa9BI3KhU_KJXJ6uyJ_rW4nQVc08,2337
@@ -31,14 +32,14 @@ nova/trame/view/theme/assets/vuetify_config.json,sha256=a0FSgpLYWGFlRGSMhMq61MyD
 nova/trame/view/theme/exit_button.py,sha256=Kqv1GVJZGrSsj6_JFjGU3vm3iNuMolLC2T1x2IsdmV0,3094
 nova/trame/view/theme/theme.py,sha256=8JqSrEbhxK1SccXE1_jUdel9Wtc2QNObVEwtbVWG_QY,13146
 nova/trame/view/utilities/local_storage.py,sha256=vD8f2VZIpxhIKjZwEaD7siiPCTZO4cw9AfhwdawwYLY,3218
-nova/trame/view_model/data_selector.py,sha256=8XBCc12CcQfctOyz5zAOZTIXddKfpzIp8A_yZI-MpFc,2499
+nova/trame/view_model/data_selector.py,sha256=LeVbrBatzwffiOywI8M7F9ldZxlpi92rFRishHkFhmo,2975
 nova/trame/view_model/execution_buttons.py,sha256=MfKSp95D92EqpD48C15cBo6dLO0Yld4FeRZMJNxJf7Y,3551
-nova/trame/view_model/ornl/neutron_data_selector.py,sha256=CtVva_MXWGRG_KclE4ln8XJP_dfy6-5unE3pjEStOpE,2074
+nova/trame/view_model/ornl/neutron_data_selector.py,sha256=l1l_e0CFsVZ0h-9MPSjXTA2w1rgH3KoGAS67UyL8DvY,1551
 nova/trame/view_model/progress_bar.py,sha256=6AUKHF3hfzbdsHqNEnmHRgDcBKY5TT8ywDx9S6ovnsc,2854
 nova/trame/view_model/remote_file_input.py,sha256=ojEOJ8ZPkajpbAaZi9VLj7g-uBjhb8BMrTdMmwf_J6A,3367
 nova/trame/view_model/tool_outputs.py,sha256=ev6LY7fJ0H2xAJn9f5ww28c8Kpom2SYc2FbvFcoN4zg,829
-nova_trame-0.23.0.dist-info/LICENSE,sha256=Iu5QiDbwNbREg75iYaxIJ_V-zppuv4QFuBhAW-qiAlM,1061
-nova_trame-0.23.0.dist-info/METADATA,sha256=vKtoLVHkJVqpA4yqwZZmjWWoYdPk1avkhUc5B8KuF80,1688
-nova_trame-0.23.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-nova_trame-0.23.0.dist-info/entry_points.txt,sha256=J2AmeSwiTYZ4ZqHHp9HO6v4MaYQTTBPbNh6WtoqOT58,42
-nova_trame-0.23.0.dist-info/RECORD,,
+nova_trame-0.24.0.dist-info/LICENSE,sha256=Iu5QiDbwNbREg75iYaxIJ_V-zppuv4QFuBhAW-qiAlM,1061
+nova_trame-0.24.0.dist-info/METADATA,sha256=pSBLrSiLCUFV9pg6yj-m9ZlQjUYT7Ms2uef6QYr2gKI,1688
+nova_trame-0.24.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+nova_trame-0.24.0.dist-info/entry_points.txt,sha256=J2AmeSwiTYZ4ZqHHp9HO6v4MaYQTTBPbNh6WtoqOT58,42
+nova_trame-0.24.0.dist-info/RECORD,,