nova-trame 0.22.1__py3-none-any.whl → 0.23.1__py3-none-any.whl

nova/trame/model/data_selector.py

@@ -3,142 +3,29 @@
 import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional
-from warnings import warn
 
 from natsort import natsorted
-from pydantic import BaseModel, Field, field_validator, model_validator
-from typing_extensions import Self
-
-CUSTOM_DIRECTORIES_LABEL = "Custom Directory"
-
-INSTRUMENTS = {
-    "HFIR": {
-        "CG-1A": "CG1A",
-        "CG-1B": "CG1B",
-        "CG-1D": "CG1D",
-        "CG-2": "CG2",
-        "CG-3": "CG3",
-        "CG-4B": "CG4B",
-        "CG-4C": "CG4C",
-        "CG-4D": "CG4D",
-        "HB-1": "HB1",
-        "HB-1A": "HB1A",
-        "HB-2A": "HB2A",
-        "HB-2B": "HB2B",
-        "HB-2C": "HB2C",
-        "HB-3": "HB3",
-        "HB-3A": "HB3A",
-        "NOW-G": "NOWG",
-        "NOW-V": "NOWV",
-    },
-    "SNS": {
-        "BL-18": "ARCS",
-        "BL-0": "BL0",
-        "BL-2": "BSS",
-        "BL-5": "CNCS",
-        "BL-9": "CORELLI",
-        "BL-6": "EQSANS",
-        "BL-14B": "HYS",
-        "BL-11B": "MANDI",
-        "BL-1B": "NOM",
-        "NOW-G": "NOWG",
-        "BL-15": "NSE",
-        "BL-11A": "PG3",
-        "BL-4B": "REF_L",
-        "BL-4A": "REF_M",
-        "BL-17": "SEQ",
-        "BL-3": "SNAP",
-        "BL-12": "TOPAZ",
-        "BL-1A": "USANS",
-        "BL-10": "VENUS",
-        "BL-16B": "VIS",
-        "BL-7": "VULCAN",
-    },
-}
+from pydantic import BaseModel, Field
 
 
 class DataSelectorState(BaseModel, validate_assignment=True):
     """Selection state for identifying datafiles."""
 
-    allow_custom_directories: bool = Field(default=False)
-    facility: str = Field(default="", title="Facility")
-    instrument: str = Field(default="", title="Instrument")
-    experiment: str = Field(default="", title="Experiment")
-    custom_directory: str = Field(default="", title="Custom Directory")
     directory: str = Field(default="")
+    subdirectory: str = Field(default="")
     extensions: List[str] = Field(default=[])
     prefix: str = Field(default="")
 
-    @field_validator("experiment", mode="after")
-    @classmethod
-    def validate_experiment(cls, experiment: str) -> str:
-        if experiment and not experiment.startswith("IPTS-"):
-            raise ValueError("experiment must begin with IPTS-")
-        return experiment
-
-    @model_validator(mode="after")
-    def validate_state(self) -> Self:
-        valid_facilities = self.get_facilities()
-        if self.facility and self.facility not in valid_facilities:
-            warn(f"Facility '{self.facility}' could not be found. Valid options: {valid_facilities}", stacklevel=1)
-
-        valid_instruments = self.get_instruments()
-        if self.instrument and self.facility != CUSTOM_DIRECTORIES_LABEL and self.instrument not in valid_instruments:
-            warn(
-                (
-                    f"Instrument '{self.instrument}' could not be found in '{self.facility}'. "
-                    f"Valid options: {valid_instruments}"
-                ),
-                stacklevel=1,
-            )
-        # Validating the experiment is expensive and will fail in our CI due to the filesystem not being mounted there.
-
-        return self
-
-    def get_facilities(self) -> List[str]:
-        facilities = list(INSTRUMENTS.keys())
-        if self.allow_custom_directories:
-            facilities.append(CUSTOM_DIRECTORIES_LABEL)
-        return facilities
-
-    def get_instruments(self) -> List[str]:
-        return list(INSTRUMENTS.get(self.facility, {}).keys())
-
 
 class DataSelectorModel:
     """Manages file system interactions for the DataSelector widget."""
 
-    def __init__(
-        self, facility: str, instrument: str, extensions: List[str], prefix: str, allow_custom_directories: bool
-    ) -> None:
-        self.state = DataSelectorState()
-        self.state.facility = facility
-        self.state.instrument = instrument
+    def __init__(self, state: DataSelectorState, directory: str, extensions: List[str], prefix: str) -> None:
+        self.state: DataSelectorState = state
+
+        self.state.directory = directory
         self.state.extensions = extensions
         self.state.prefix = prefix
-        self.state.allow_custom_directories = allow_custom_directories
-
-    def get_facilities(self) -> List[str]:
-        return natsorted(self.state.get_facilities())
-
-    def get_instrument_dir(self) -> str:
-        return INSTRUMENTS.get(self.state.facility, {}).get(self.state.instrument, "")
-
-    def get_instruments(self) -> List[str]:
-        return natsorted(self.state.get_instruments())
-
-    def get_experiments(self) -> List[str]:
-        experiments = []
-
-        instrument_path = Path("/") / self.state.facility / self.get_instrument_dir()
-        try:
-            for dirname in os.listdir(instrument_path):
-                if dirname.startswith("IPTS-") and os.access(instrument_path / dirname, mode=os.R_OK):
-                    experiments.append(dirname)
-        except OSError:
-            pass
-
-        return natsorted(experiments)
 
     def sort_directories(self, directories: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         # Sort the current level of dictionaries
@@ -151,31 +38,7 @@ class DataSelectorModel:
 
         return sorted_dirs
 
-    def get_experiment_directory_path(self) -> Optional[Path]:
-        if not self.state.experiment:
-            return None
-
-        return Path("/") / self.state.facility / self.get_instrument_dir() / self.state.experiment
-
-    def get_custom_directory_path(self) -> Optional[Path]:
-        # Don't expose the full file system
-        if not self.state.custom_directory:
-            return None
-
-        return Path(self.state.custom_directory)
-
-    def get_directories(self, base_path: Optional[Path] = None) -> List[Dict[str, Any]]:
-        using_custom_directory = self.state.facility == CUSTOM_DIRECTORIES_LABEL
-        if base_path:
-            pass
-        elif using_custom_directory:
-            base_path = self.get_custom_directory_path()
-        else:
-            base_path = self.get_experiment_directory_path()
-
-        if not base_path:
-            return []
-
+    def get_directories_from_path(self, base_path: Path) -> List[Dict[str, Any]]:
         directories = []
         try:
             for dirpath, dirs, _ in os.walk(base_path):
@@ -184,6 +47,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
@@ -208,21 +75,24 @@ class DataSelectorModel:
 
         return self.sort_directories(directories)
 
-    def get_datafiles(self) -> List[str]:
-        datafiles = []
-
-        if self.state.experiment:
-            base_path = Path("/") / self.state.facility / self.get_instrument_dir() / self.state.experiment
-        elif self.state.custom_directory:
-            base_path = Path(self.state.custom_directory)
+    def get_directories(self, base_path: Optional[Path] = None) -> List[Dict[str, Any]]:
+        if base_path:
+            pass
         else:
+            base_path = Path(self.state.directory)
+
+        if not base_path:
             return []
 
+        return self.get_directories_from_path(base_path)
+
+    def get_datafiles_from_path(self, base_path: Path) -> List[str]:
+        datafiles = []
         try:
             if self.state.prefix:
-                datafile_path = str(base_path / self.state.prefix)
+                datafile_path = base_path / self.state.prefix
             else:
-                datafile_path = str(base_path / self.state.directory)
+                datafile_path = base_path / self.state.subdirectory
 
             for entry in os.scandir(datafile_path):
                 if entry.is_file():
@@ -237,13 +107,10 @@ class DataSelectorModel:
 
         return natsorted(datafiles)
 
-    def set_directory(self, directory_path: str) -> None:
-        self.state.directory = directory_path
+    def get_datafiles(self) -> List[str]:
+        base_path = Path(self.state.directory)
+
+        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
+    def set_subdirectory(self, subdirectory_path: str) -> None:
+        self.state.subdirectory = subdirectory_path

nova/trame/model/ornl/neutron_data_selector.py

@@ -0,0 +1,193 @@
+"""Model implementation for DataSelector."""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from warnings import warn
+
+from natsort import natsorted
+from pydantic import Field, field_validator, model_validator
+from typing_extensions import Self
+
+from ..data_selector import DataSelectorModel, DataSelectorState
+
+CUSTOM_DIRECTORIES_LABEL = "Custom Directory"
+
+INSTRUMENTS = {
+    "HFIR": {
+        "CG-1A": "CG1A",
+        "CG-1B": "CG1B",
+        "CG-1D": "CG1D",
+        "CG-2": "CG2",
+        "CG-3": "CG3",
+        "CG-4B": "CG4B",
+        "CG-4C": "CG4C",
+        "CG-4D": "CG4D",
+        "HB-1": "HB1",
+        "HB-1A": "HB1A",
+        "HB-2A": "HB2A",
+        "HB-2B": "HB2B",
+        "HB-2C": "HB2C",
+        "HB-3": "HB3",
+        "HB-3A": "HB3A",
+        "NOW-G": "NOWG",
+        "NOW-V": "NOWV",
+    },
+    "SNS": {
+        "BL-18": "ARCS",
+        "BL-0": "BL0",
+        "BL-2": "BSS",
+        "BL-5": "CNCS",
+        "BL-9": "CORELLI",
+        "BL-6": "EQSANS",
+        "BL-14B": "HYS",
+        "BL-11B": "MANDI",
+        "BL-1B": "NOM",
+        "NOW-G": "NOWG",
+        "BL-15": "NSE",
+        "BL-11A": "PG3",
+        "BL-4B": "REF_L",
+        "BL-4A": "REF_M",
+        "BL-17": "SEQ",
+        "BL-3": "SNAP",
+        "BL-12": "TOPAZ",
+        "BL-1A": "USANS",
+        "BL-10": "VENUS",
+        "BL-16B": "VIS",
+        "BL-7": "VULCAN",
+    },
+}
+
+
+class NeutronDataSelectorState(DataSelectorState):
+    """Selection state for identifying datafiles."""
+
+    allow_custom_directories: bool = Field(default=False)
+    facility: str = Field(default="", title="Facility")
+    instrument: str = Field(default="", title="Instrument")
+    experiment: str = Field(default="", title="Experiment")
+    custom_directory: str = Field(default="", title="Custom Directory")
+
+    @field_validator("experiment", mode="after")
+    @classmethod
+    def validate_experiment(cls, experiment: str) -> str:
+        if experiment and not experiment.startswith("IPTS-"):
+            raise ValueError("experiment must begin with IPTS-")
+        return experiment
+
+    @model_validator(mode="after")
+    def validate_state(self) -> Self:
+        valid_facilities = self.get_facilities()
+        if self.facility and self.facility not in valid_facilities:
+            warn(f"Facility '{self.facility}' could not be found. Valid options: {valid_facilities}", stacklevel=1)
+
+        valid_instruments = self.get_instruments()
+        if self.instrument and self.facility != CUSTOM_DIRECTORIES_LABEL and self.instrument not in valid_instruments:
+            warn(
+                (
+                    f"Instrument '{self.instrument}' could not be found in '{self.facility}'. "
+                    f"Valid options: {valid_instruments}"
+                ),
+                stacklevel=1,
+            )
+        # Validating the experiment is expensive and will fail in our CI due to the filesystem not being mounted there.
+
+        return self
+
+    def get_facilities(self) -> List[str]:
+        facilities = list(INSTRUMENTS.keys())
+        if self.allow_custom_directories:
+            facilities.append(CUSTOM_DIRECTORIES_LABEL)
+        return facilities
+
+    def get_instruments(self) -> List[str]:
+        return list(INSTRUMENTS.get(self.facility, {}).keys())
+
+
+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)
+        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 get_facilities(self) -> List[str]:
+        return natsorted(self.state.get_facilities())
+
+    def get_instrument_dir(self) -> str:
+        return INSTRUMENTS.get(self.state.facility, {}).get(self.state.instrument, "")
+
+    def get_instruments(self) -> List[str]:
+        return natsorted(self.state.get_instruments())
+
+    def get_experiments(self) -> List[str]:
+        experiments = []
+
+        instrument_path = Path("/") / self.state.facility / self.get_instrument_dir()
+        try:
+            for dirname in os.listdir(instrument_path):
+                if dirname.startswith("IPTS-") and os.access(instrument_path / dirname, mode=os.R_OK):
+                    experiments.append(dirname)
+        except OSError:
+            pass
+
+        return natsorted(experiments)
+
+    def get_experiment_directory_path(self) -> Optional[Path]:
+        if not self.state.experiment:
+            return None
+
+        return Path("/") / self.state.facility / self.get_instrument_dir() / self.state.experiment
+
+    def get_custom_directory_path(self) -> Optional[Path]:
+        # Don't expose the full file system
+        if not self.state.custom_directory:
+            return None
+
+        return Path(self.state.custom_directory)
+
+    def get_directories(self, base_path: Optional[Path] = None) -> List[Dict[str, Any]]:
+        using_custom_directory = self.state.facility == CUSTOM_DIRECTORIES_LABEL
+        if base_path:
+            pass
+        elif using_custom_directory:
+            base_path = self.get_custom_directory_path()
+        else:
+            base_path = self.get_experiment_directory_path()
+
+        if not base_path:
+            return []
+
+        return self.get_directories_from_path(base_path)
+
+    def get_datafiles(self) -> List[str]:
+        if self.state.experiment:
+            base_path = Path("/") / self.state.facility / self.get_instrument_dir() / self.state.experiment
+        elif self.state.custom_directory:
+            base_path = Path(self.state.custom_directory)
+        else:
+            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,15 +1,15 @@
 """View Implementation for DataSelector."""
 
+from asyncio import ensure_future, sleep
 from typing import Any, List, Optional, 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 nova.mvvm.trame_binding import TrameBinding
-from nova.trame.model.data_selector import CUSTOM_DIRECTORIES_LABEL, DataSelectorModel
-from nova.trame.view.layouts import GridLayout, VBoxLayout
+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
 
 from .input_field import InputField
@@ -18,16 +18,15 @@ vuetify.enable_lab()
 
 
 class DataSelector(datagrid.VGrid):
-    """Allows the user to select datafiles from an IPTS experiment."""
+    """Allows the user to select datafiles from the server."""
 
     def __init__(
         self,
         v_model: str,
-        allow_custom_directories: bool = False,
-        facility: str = "",
-        instrument: str = "",
+        directory: str,
         extensions: Optional[List[str]] = None,
         prefix: str = "",
+        refresh_rate: int = 30,
         select_strategy: str = "all",
         **kwargs: Any,
     ) -> None:
@@ -38,18 +37,17 @@ class DataSelector(datagrid.VGrid):
         v_model : str
             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
-            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
-            The facility to restrict data selection to. Options: HFIR, SNS
-        instrument : str, optional
-            The instrument to restrict data selection to. Please use the instrument acronym (e.g. CG-2).
+        directory : str
+            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
             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.
+            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
+            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
             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.
@@ -61,6 +59,12 @@ class DataSelector(datagrid.VGrid):
         -------
         None
         """
+        if "allow_custom_directory" in kwargs or "facility" in kwargs or "instrument" in kwargs:
+            raise TypeError(
+                "The old DataSelector component has been renamed to NeutronDataSelector. Please import it from "
+                "`nova.trame.view.components.ornl`."
+            )
+
         if "items" in kwargs:
             raise AttributeError("The items parameter is not allowed on DataSelector widget.")
 
@@ -69,21 +73,16 @@ class DataSelector(datagrid.VGrid):
         else:
             self._label = None
 
-        if facility and allow_custom_directories:
-            warn("allow_custom_directories will be ignored since the facility parameter is set.", stacklevel=1)
-
         self._v_model = v_model
         self._v_model_name_in_state = v_model.split(".")[0]
-        self._allow_custom_directories = allow_custom_directories
+        self._directory = directory
         self._extensions = extensions if extensions is not None else []
         self._prefix = prefix
+        self._refresh_rate = refresh_rate
         self._select_strategy = select_strategy
 
         self._revogrid_id = f"nova__dataselector_{self._next_id}_rv"
         self._state_name = f"nova__dataselector_{self._next_id}_state"
-        self._facilities_name = f"nova__dataselector_{self._next_id}_facilities"
-        self._instruments_name = f"nova__dataselector_{self._next_id}_instruments"
-        self._experiments_name = f"nova__dataselector_{self._next_id}_experiments"
         self._directories_name = f"nova__dataselector_{self._next_id}_directories"
         self._datafiles_name = f"nova__dataselector_{self._next_id}_datafiles"
 
@@ -93,36 +92,22 @@ class DataSelector(datagrid.VGrid):
         ).exec
         self._reset_state = client.JSEval(exec=f"{self._v_model} = []; {self._flush_state}").exec
 
-        self.create_model(facility, instrument)
+        self.create_model()
         self.create_viewmodel()
 
-        self.create_ui(facility, instrument, **kwargs)
+        self.create_ui(**kwargs)
 
-    def create_ui(self, facility: str, instrument: str, **kwargs: Any) -> None:
-        with VBoxLayout(classes="nova-data-selector", height="100%"):
-            with GridLayout(columns=3):
-                columns = 3
-                if facility == "":
-                    columns -= 1
-                    InputField(
-                        v_model=f"{self._state_name}.facility", items=(self._facilities_name,), type="autocomplete"
-                    )
-                if instrument == "":
-                    columns -= 1
-                    InputField(
-                        v_if=f"{self._state_name}.facility !== '{CUSTOM_DIRECTORIES_LABEL}'",
-                        v_model=f"{self._state_name}.instrument",
-                        items=(self._instruments_name,),
-                        type="autocomplete",
-                    )
-                InputField(
-                    v_if=f"{self._state_name}.facility !== '{CUSTOM_DIRECTORIES_LABEL}'",
-                    v_model=f"{self._state_name}.experiment",
-                    column_span=columns,
-                    items=(self._experiments_name,),
-                    type="autocomplete",
-                )
-                InputField(v_else=True, v_model=f"{self._state_name}.custom_directory", column_span=2)
+        ensure_future(self._refresh_loop())
+
+    def create_ui(self, *args: Any, **kwargs: Any) -> None:
+        with VBoxLayout(classes="nova-data-selector", height="100%") as self._layout:
+            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:
@@ -137,7 +122,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_directory, "$event"),
+                            update_activated=(self._vm.set_subdirectory, "$event"),
                         )
                         vuetify.VListItem("No directories found", classes="flex-0-1 text-center", v_else=True)
 
@@ -198,10 +183,9 @@ class DataSelector(datagrid.VGrid):
                         f"(+{{{{ {self._v_model}.length - 2 }}}} others)", v_if="index === 2", classes="text-caption"
                     )
 
-    def create_model(self, facility: str, instrument: str) -> None:
-        self._model = DataSelectorModel(
-            facility, instrument, self._extensions, self._prefix, self._allow_custom_directories
-        )
+    def create_model(self) -> None:
+        state = DataSelectorState()
+        self._model = DataSelectorModel(state, self._directory, self._extensions, self._prefix)
 
     def create_viewmodel(self) -> None:
         server = get_server(None, client_type="vue3")
@@ -209,39 +193,29 @@ class DataSelector(datagrid.VGrid):
 
         self._vm = DataSelectorViewModel(self._model, binding)
         self._vm.state_bind.connect(self._state_name)
-        self._vm.facilities_bind.connect(self._facilities_name)
-        self._vm.instruments_bind.connect(self._instruments_name)
-        self._vm.experiments_bind.connect(self._experiments_name)
         self._vm.directories_bind.connect(self._directories_name)
         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_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.
-
-        If a parameter is None, then it will not be updated.
+    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`."
+        )
 
-        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.
+    async def _refresh_loop(self) -> None:
+        if self._refresh_rate > 0:
+            while True:
+                await sleep(self._refresh_rate)
 
-        Returns
-        -------
-        None
-        """
-        self._vm.set_state(facility, instrument, experiment)
+                self.refresh_contents()
+                self.state.dirty(self._datafiles_name)

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

@@ -0,0 +1,3 @@
+from .neutron_data_selector import NeutronDataSelector
+
+__all__ = ["NeutronDataSelector"]

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

@@ -0,0 +1,155 @@
+"""View Implementation for DataSelector."""
+
+from typing import Any, List, Optional
+from warnings import warn
+
+from trame.app import get_server
+from trame.widgets import vuetify3 as vuetify
+
+from nova.mvvm.trame_binding import TrameBinding
+from nova.trame.model.ornl.neutron_data_selector import (
+    CUSTOM_DIRECTORIES_LABEL,
+    NeutronDataSelectorModel,
+    NeutronDataSelectorState,
+)
+from nova.trame.view.layouts import GridLayout
+from nova.trame.view_model.ornl.neutron_data_selector import NeutronDataSelectorViewModel
+
+from ..data_selector import DataSelector
+from ..input_field import InputField
+
+vuetify.enable_lab()
+
+
+class NeutronDataSelector(DataSelector):
+    """Allows the user to select datafiles from an IPTS experiment."""
+
+    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",
+        **kwargs: Any,
+    ) -> None:
+        """Constructor for DataSelector.
+
+        Parameters
+        ----------
+        v_model : str
+            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
+            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
+            The facility to restrict data selection to. Options: HFIR, SNS
+        instrument : str, optional
+            The instrument to restrict data selection to. Please use the instrument acronym (e.g. CG-2).
+        extensions : List[str], 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
+            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
+            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
+            All other arguments will be passed to the underlying
+            `VDataTable component <https://trame.readthedocs.io/en/latest/trame.widgets.vuetify3.html#trame.widgets.vuetify3.VDataTable>`_.
+
+        Returns
+        -------
+        None
+        """
+        if facility and allow_custom_directories:
+            warn("allow_custom_directories will be ignored since the facility parameter is set.", stacklevel=1)
+
+        self._facility = facility
+        self._instrument = instrument
+        self._allow_custom_directories = allow_custom_directories
+
+        self._facilities_name = f"nova__neutrondataselector_{self._next_id}_facilities"
+        self._instruments_name = f"nova__neutrondataselector_{self._next_id}_instruments"
+        self._experiments_name = f"nova__neutrondataselector_{self._next_id}_experiments"
+
+        super().__init__(v_model, "", extensions, prefix, refresh_rate, 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 == "":
+                    columns -= 1
+                    InputField(
+                        v_model=f"{self._state_name}.facility", items=(self._facilities_name,), type="autocomplete"
+                    )
+                if self._instrument == "":
+                    columns -= 1
+                    InputField(
+                        v_if=f"{self._state_name}.facility !== '{CUSTOM_DIRECTORIES_LABEL}'",
+                        v_model=f"{self._state_name}.instrument",
+                        items=(self._instruments_name,),
+                        type="autocomplete",
+                    )
+                InputField(
+                    v_if=f"{self._state_name}.facility !== '{CUSTOM_DIRECTORIES_LABEL}'",
+                    v_model=f"{self._state_name}.experiment",
+                    column_span=columns,
+                    items=(self._experiments_name,),
+                    type="autocomplete",
+                )
+                InputField(v_else=True, v_model=f"{self._state_name}.custom_directory", column_span=2)
+
+    def create_model(self) -> None:
+        state = NeutronDataSelectorState()
+        self._model: NeutronDataSelectorModel = NeutronDataSelectorModel(
+            state, self._facility, self._instrument, self._extensions, self._prefix, self._allow_custom_directories
+        )
+
+    def create_viewmodel(self) -> None:
+        server = get_server(None, client_type="vue3")
+        binding = TrameBinding(server.state)
+
+        self._vm: NeutronDataSelectorViewModel = NeutronDataSelectorViewModel(self._model, binding)
+        self._vm.state_bind.connect(self._state_name)
+        self._vm.facilities_bind.connect(self._facilities_name)
+        self._vm.instruments_bind.connect(self._instruments_name)
+        self._vm.experiments_bind.connect(self._experiments_name)
+        self._vm.directories_bind.connect(self._directories_name)
+        self._vm.datafiles_bind.connect(self._datafiles_name)
+        self._vm.reset_bind.connect(self.reset)
+
+        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.
+
+        If a parameter is None, then it will not be updated.
+
+        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.
+
+        Returns
+        -------
+        None
+        """
+        self._vm.set_state(facility, instrument, experiment)

nova/trame/view/theme/assets/core_style.scss

@@ -22,8 +22,14 @@ html {
 
 .nova-data-selector {
     .v-list-group {
-        .v-treeview-item {
-            --indent-padding: 1em !important;
+        --prepend-width: 12px !important;
+    }
+
+    .v-treeview.v-list {
+        --indent-padding: 0px !important;
+
+        & > .v-list-group > .v-list-item {
+            padding-left: 0 !important;
         }
     }
 }

nova/trame/view_model/data_selector.py

@@ -2,7 +2,7 @@
 
 import os
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
 from nova.mvvm.interface import BindingInterface
 from nova.trame.model.data_selector import DataSelectorModel
@@ -12,16 +12,13 @@ class DataSelectorViewModel:
     """Manages the view state of the DataSelector widget."""
 
     def __init__(self, model: DataSelectorModel, binding: BindingInterface) -> None:
-        self.model = model
+        self.model: DataSelectorModel = model
 
         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.facilities_bind = binding.new_bind()
-        self.instruments_bind = binding.new_bind()
-        self.experiments_bind = binding.new_bind()
         self.directories_bind = binding.new_bind()
         self.datafiles_bind = binding.new_bind()
         self.reset_bind = binding.new_bind()
@@ -47,43 +44,28 @@ 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 set_directory(self, directory_path: str = "") -> None:
-        self.model.set_directory(directory_path)
-        self.update_view()
-
-    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 reexpand_directories(self) -> None:
+        paths_to_expand = self.expanded.values()
+        self.expanded = {}
 
-    def reset(self) -> None:
-        self.model.set_directory("")
-        self.directories = self.model.get_directories()
-        self.expanded = []
-        self.reset_bind.update_in_view(None)
+        for paths in paths_to_expand:
+            self.expand_directory(paths)
 
     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()
+        pass
+
+    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)
-        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())
+        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

@@ -0,0 +1,51 @@
+"""View model implementation for the DataSelector widget."""
+
+from typing import Any, Dict, Optional
+
+from nova.mvvm.interface import BindingInterface
+from nova.trame.model.ornl.neutron_data_selector import NeutronDataSelectorModel
+from nova.trame.view_model.data_selector import DataSelectorViewModel
+
+
+class NeutronDataSelectorViewModel(DataSelectorViewModel):
+    """Manages the view state of the DataSelector widget."""
+
+    def __init__(self, model: NeutronDataSelectorModel, binding: BindingInterface) -> None:
+        super().__init__(model, binding)
+        self.model: NeutronDataSelectorModel = model
+
+        self.facilities_bind = binding.new_bind()
+        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.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()
+
+    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(refresh_directories)

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.3
 Name: nova-trame
-Version: 0.22.1
+Version: 0.23.1
 Summary: A Python Package for injecting curated themes and custom components into Trame applications
 License: MIT
 Keywords: NDIP,Python,Trame,Vuetify
-Author: Duggan, John
+Author: John Duggan
 Author-email: dugganjw@ornl.gov
 Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: MIT License

{nova_trame-0.22.1.dist-info → nova_trame-0.23.1.dist-info}/RECORD

@@ -1,12 +1,15 @@
 nova/__init__.py,sha256=ED6jHcYiuYpr_0vjGz0zx2lrrmJT9sDJCzIljoDfmlM,65
 nova/trame/__init__.py,sha256=gFrAg1qva5PIqR5TjvPzAxLx103IKipJLqp3XXvrQL8,59
-nova/trame/model/data_selector.py,sha256=UnLBCp_jJ523QxTR3R8iun2Ogq4D0G0lxmtW9e_zwOM,8938
+nova/trame/model/data_selector.py,sha256=8eaIVGak6XOAQMxdUotOsiXisW14sSRd1V0oViglJVQ,4448
+nova/trame/model/ornl/neutron_data_selector.py,sha256=nfjXwT93JcPjJwyDynoP_stDVAfjUs7neeVZTk_04gc,6424
 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=lgZjyT_jc3eE19HNgz_Hdog5bWvXZJ3IfxxiSBkZ7hE,11222
+nova/trame/view/components/data_selector.py,sha256=d5UDF7ENBNifmLyIecx8VyINRY4vSxlQHyJ2a5G7IOY,9606
 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/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
@@ -19,7 +22,7 @@ nova/trame/view/layouts/hbox.py,sha256=qlOMp_iOropIkC9Jxa6D89b7OPv0pNvJ73tUEzddy
 nova/trame/view/layouts/utils.py,sha256=Hg34VQWTG3yHBsgNvmfatR4J-uL3cko7UxSJpT-h3JI,376
 nova/trame/view/layouts/vbox.py,sha256=hzhzPu99R2fAclMe-FwHZseJWk7iailZ31bKdGhi1hk,3514
 nova/trame/view/theme/__init__.py,sha256=70_marDlTigIcPEOGiJb2JTs-8b2sGM5SlY7XBPtBDM,54
-nova/trame/view/theme/assets/core_style.scss,sha256=lK86Fp55oAMDh1eUHA-DTeGGZi0uUYOseIyJUTj-0A0,4081
+nova/trame/view/theme/assets/core_style.scss,sha256=AJ-2hyQRVkyOGWJB0lGMzlQeshbCJP5BGNYCt9e9AOI,4208
 nova/trame/view/theme/assets/favicon.png,sha256=Xbp1nUmhcBDeObjsebEbEAraPDZ_M163M_ZLtm5AbQc,1927
 nova/trame/view/theme/assets/js/delay_manager.js,sha256=mRV6KoO8-Bxq3tG5Bh9CQYy-CRVbkj3IYlqNb-Og7cI,526
 nova/trame/view/theme/assets/js/lodash.min.js,sha256=KCyAYJ-fsqtp_HMwbjhy6IKjlA5lrVrtWt1JdMsC57k,73016
@@ -28,13 +31,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=RyMHml1K_pupH4JtXnGxAaYTYYwNoEVus7Abdpqwueo,3698
+nova/trame/view_model/data_selector.py,sha256=yDyYceZAUIxv4hhJGAPdIo54zHmrwqkxNZh7F2sRlw0,2810
 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/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.22.1.dist-info/LICENSE,sha256=Iu5QiDbwNbREg75iYaxIJ_V-zppuv4QFuBhAW-qiAlM,1061
-nova_trame-0.22.1.dist-info/METADATA,sha256=A-wOqVcFQXeV1qpuPJv253RugeWK5j2UryAUYdwgtII,1689
-nova_trame-0.22.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-nova_trame-0.22.1.dist-info/entry_points.txt,sha256=J2AmeSwiTYZ4ZqHHp9HO6v4MaYQTTBPbNh6WtoqOT58,42
-nova_trame-0.22.1.dist-info/RECORD,,
+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,,