nova-trame 0.23.1__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
@@ -89,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,13 +1,17 @@
 """View Implementation for DataSelector."""
 
 from asyncio import ensure_future, sleep
-from typing import Any, List, Optional, cast
+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, HBoxLayout, VBoxLayout
 from nova.trame.view_model.data_selector import DataSelectorViewModel
@@ -22,33 +26,36 @@ class DataSelector(datagrid.VGrid):
 
     def __init__(
         self,
-        v_model: str,
-        directory: str,
-        extensions: Optional[List[str]] = None,
-        prefix: str = "",
-        refresh_rate: int = 30,
-        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.
-        refresh_rate : int, 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 : str, optional
+        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
@@ -73,11 +80,28 @@ 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
 
@@ -92,13 +116,18 @@ 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:
             with HBoxLayout(valign="center"):
@@ -110,7 +139,7 @@ class DataSelector(datagrid.VGrid):
                     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(
@@ -122,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)
 
@@ -139,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,
@@ -183,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)
 
@@ -197,8 +227,6 @@ 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)
 
@@ -206,16 +234,86 @@ class DataSelector(datagrid.VGrid):
         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:
-        if self._refresh_rate > 0:
+        refresh_rate: int = set_state_param(self.state, self._refresh_rate)
+        skip = False
+
+        if refresh_rate > 0:
             while True:
-                await sleep(self._refresh_rate)
+                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,39 +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 = "",
-        refresh_rate: int = 30,
-        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.
-        refresh_rate : int, 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 : str, optional
+        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
@@ -69,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, refresh_rate, 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)
 
@@ -130,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

@@ -57,6 +57,10 @@ class DataSelectorViewModel:
     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()

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,10 +18,6 @@ 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()
@@ -31,17 +27,9 @@ class NeutronDataSelectorViewModel(DataSelectorViewModel):
     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, refresh_directories: bool = False) -> None:
         self.facilities_bind.update_in_view(self.model.get_facilities())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nova-trame
-Version: 0.23.1
+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.1.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=8eaIVGak6XOAQMxdUotOsiXisW14sSRd1V0oViglJVQ,4448
-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=d5UDF7ENBNifmLyIecx8VyINRY4vSxlQHyJ2a5G7IOY,9606
+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=8B0BVXzVtMApnbMGD6ms6G4gdv5l-dIWM6YlHcBgnoc,6878
+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=yDyYceZAUIxv4hhJGAPdIo54zHmrwqkxNZh7F2sRlw0,2810
+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=WTuz9QO4WzbOftTH0uP9Qxn7nYdsnIoixu1hWHKCVNU,2128
+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.1.dist-info/LICENSE,sha256=Iu5QiDbwNbREg75iYaxIJ_V-zppuv4QFuBhAW-qiAlM,1061
-nova_trame-0.23.1.dist-info/METADATA,sha256=VVMLgB8JhBIzt_FbCAEUIjPh3Zu8gEqQy091t3Fpd8E,1688
-nova_trame-0.23.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-nova_trame-0.23.1.dist-info/entry_points.txt,sha256=J2AmeSwiTYZ4ZqHHp9HO6v4MaYQTTBPbNh6WtoqOT58,42
-nova_trame-0.23.1.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,,