nova-trame 0.25.3__py3-none-any.whl → 0.25.4__py3-none-any.whl

nova/trame/model/remote_file_input.py

@@ -3,21 +3,39 @@
 import os
 from functools import cmp_to_key
 from locale import strcoll
-from typing import Any, Union
+from typing import Any, List, Union
+
+from pydantic import BaseModel, Field
+
+
+class RemoteFileInputState(BaseModel):
+    """Pydantic model for RemoteFileInput state."""
+
+    allow_files: bool = Field(default=False)
+    allow_folders: bool = Field(default=False)
+    base_paths: List[str] = Field(default=[])
+    extensions: List[str] = Field(default=[])
 
 
 class RemoteFileInputModel:
     """Manages interactions between RemoteFileInput and the file system."""
 
-    def __init__(self, allow_files: bool, allow_folders: bool, base_paths: list[str], extensions: list[str]) -> None:
+    def __init__(self) -> None:
         """Creates a new RemoteFileInputModel."""
-        self.allow_files = allow_files
-        self.allow_folders = allow_folders
-        self.base_paths = base_paths
-        self.extensions = extensions
+        self.state = RemoteFileInputState()
+
+    def set_binding_parameters(self, **kwargs: Any) -> None:
+        if "allow_files" in kwargs:
+            self.state.allow_files = kwargs["allow_files"]
+        if "allow_folders" in kwargs:
+            self.state.allow_folders = kwargs["allow_folders"]
+        if "base_paths" in kwargs:
+            self.state.base_paths = kwargs["base_paths"]
+        if "extensions" in kwargs:
+            self.state.extensions = kwargs["extensions"]
 
     def get_base_paths(self) -> list[dict[str, Any]]:
-        return [{"path": base_path, "directory": True} for base_path in self.base_paths]
+        return [{"path": base_path, "directory": True} for base_path in self.state.base_paths]
 
     def scan_current_path(
         self, current_path: str, showing_all_files: bool, filter: str
@@ -72,7 +90,7 @@ class RemoteFileInputModel:
         if not showing_base_paths and file != "..":
             return os.path.join(old_path, file)
         elif not showing_base_paths:
-            if old_path in self.base_paths:
+            if old_path in self.state.base_paths:
                 return ""
             else:
                 return os.path.dirname(old_path)
@@ -83,17 +101,21 @@ class RemoteFileInputModel:
         if entry.is_dir():
             return True
 
-        if not self.allow_files:
+        if not self.state.allow_files:
             return False
 
-        return showing_all_files or not self.extensions or any(entry.name.endswith(ext) for ext in self.extensions)
+        return (
+            showing_all_files
+            or not self.state.extensions
+            or any(entry.name.endswith(ext) for ext in self.state.extensions)
+        )
 
     def valid_selection(self, selection: str) -> bool:
         if self.valid_subpath(selection):
-            if os.path.isdir(selection) and self.allow_folders:
+            if os.path.isdir(selection) and self.state.allow_folders:
                 return True
 
-            if os.path.isfile(selection) and self.allow_files:
+            if os.path.isfile(selection) and self.state.allow_files:
                 return True
 
         return False
@@ -102,7 +124,7 @@ class RemoteFileInputModel:
         if subpath == "":
             return False
 
-        for base_path in self.base_paths:
+        for base_path in self.state.base_paths:
             if subpath.startswith(base_path):
                 return True
 

nova/trame/view/components/file_upload.py

@@ -1,8 +1,12 @@
 """View implementation for FileUpload."""
 
-from typing import Any, List, Optional
+from typing import Any, List, Tuple, Union
 
+from trame.app import get_server
 from trame.widgets import vuetify3 as vuetify
+from trame_server.core import State
+
+from nova.trame._internal.utils import get_state_param
 
 from .remote_file_input import RemoteFileInput
 
@@ -12,25 +16,28 @@ class FileUpload(vuetify.VBtn):
 
     def __init__(
         self,
-        v_model: str,
-        base_paths: Optional[List[str]] = None,
+        v_model: Union[str, Tuple],
+        base_paths: Union[List[str], Tuple, None] = None,
+        extensions: Union[List[str], Tuple, None] = None,
         label: str = "",
-        return_contents: bool = True,
+        return_contents: Union[bool, Tuple] = True,
         **kwargs: Any,
     ) -> None:
         """Constructor for FileUpload.
 
         Parameters
         ----------
-        v_model : str
+        v_model : Union[str, Tuple]
             The state variable to set when the user uploads their file. The state variable will contain a latin1-decoded
             version of the file contents. If your file is binary or requires a different string encoding, then you can
             call `encode('latin1')` on the file contents to get the underlying bytes.
-        base_paths: list[str], optional
+        base_paths: Union[List[str], Tuple], optional
             Passed to :ref:`RemoteFileInput <api_remotefileinput>`.
+        extensions: Union[List[str], Tuple], optional
+            Restricts the files shown to the user to files that end with one of the strings in the list.
         label : str, optional
             The text to display on the upload button.
-        return_contents : bool, optional
+        return_contents : Union[bool, Tuple], optional
             If true, the file contents will be stored in v_model. If false, a file path will be stored in v_model.
             Defaults to true.
         **kwargs
@@ -41,20 +48,26 @@ class FileUpload(vuetify.VBtn):
         -------
         None
         """
+        self._server = get_server(None, client_type="vue3")
+
         self._v_model = v_model
-        if base_paths:
-            self._base_paths = base_paths
-        else:
-            self._base_paths = ["/"]
+        self._base_paths = base_paths if base_paths else ["/"]
+        self._extensions = extensions if extensions else []
         self._return_contents = return_contents
         self._ref_name = f"nova__fileupload_{self._next_id}"
 
         super().__init__(label, **kwargs)
         self.create_ui()
 
+    @property
+    def state(self) -> State:
+        return self._server.state
+
     def create_ui(self) -> None:
         self.local_file_input = vuetify.VFileInput(
-            v_model=(self._v_model, None),
+            v_model=self._v_model,
+            __properties=["accept"],
+            accept=",".join(self._extensions) if isinstance(self._extensions, list) else self._extensions,
             classes="d-none",
             ref=self._ref_name,
             # Serialize the content in a way that will work with nova-mvvm and then push it to the server.
@@ -67,6 +80,7 @@ class FileUpload(vuetify.VBtn):
         self.remote_file_input = RemoteFileInput(
             v_model=self._v_model,
             base_paths=self._base_paths,
+            extensions=self._extensions,
             input_props={"classes": "d-none"},
             return_contents=self._return_contents,
         )
@@ -79,7 +93,7 @@ class FileUpload(vuetify.VBtn):
 
         @self.server.controller.trigger(f"decode_blob_{self._id}")
         def _decode_blob(contents: bytes) -> None:
-            self.remote_file_input.decode_file(contents, self._return_contents)
+            self.remote_file_input.decode_file(contents, get_state_param(self.state, self._return_contents))
 
     def select_file(self, value: str) -> None:
         """Programmatically set the RemoteFileInput path.

nova/trame/view/components/input_field.py

@@ -5,7 +5,7 @@ import os
 import re
 from enum import Enum
 from inspect import isclass
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Tuple, Union
 
 from trame.app import get_server
 from trame.widgets import client
@@ -15,6 +15,7 @@ from trame_server.controller import Controller
 from trame_server.state import State
 
 from nova.mvvm.pydantic_utils import get_field_info
+from nova.trame._internal.utils import set_state_param
 
 logger = logging.getLogger(__name__)
 
@@ -22,9 +23,14 @@ logger = logging.getLogger(__name__)
 class InputField:
     """Factory class for generating Vuetify input components."""
 
+    next_id = 0
+
     @staticmethod
     def create_boilerplate_properties(
-        v_model: Optional[Union[tuple[str, Any], str]], field_type: str, debounce: int, throttle: int
+        v_model: Union[str, Tuple, None],
+        field_type: str,
+        debounce: Union[int, Tuple],
+        throttle: Union[int, Tuple],
     ) -> dict:
         if debounce == -1:
             debounce = int(os.environ.get("NOVA_TRAME_DEFAULT_DEBOUNCE", 0))
@@ -78,26 +84,43 @@ class InputField:
                 ):
                     args |= {"items": str([option.value for option in field_info.annotation])}
 
-            if debounce > 0 and throttle > 0:
+            if debounce and throttle:
                 raise ValueError("debounce and throttle cannot be used together")
 
-            if debounce > 0:
+            server = get_server(None, client_type="vue3")
+            if debounce:
+                if isinstance(debounce, tuple):
+                    debounce_field = debounce[0]
+                    set_state_param(server.state, debounce)
+                else:
+                    debounce_field = f"nova__debounce_{InputField.next_id}"
+                    InputField.next_id += 1
+                    set_state_param(server.state, debounce_field, debounce)
+
                 args |= {
                     "update_modelValue": (
                         "window.delay_manager.debounce("
-                        f"  '{v_model}',"
+                        f"  '{field}',"
                         f"  () => flushState('{object_name_in_state}'),"
-                        f"  {debounce}"
+                        f"  {debounce_field}"
                         ")"
                     )
                 }
-            elif throttle > 0:
+            elif throttle:
+                if isinstance(throttle, tuple):
+                    throttle_field = throttle[0]
+                    set_state_param(server.state, throttle)
+                else:
+                    throttle_field = f"nova__throttle_{InputField.next_id}"
+                    InputField.next_id += 1
+                    set_state_param(server.state, throttle_field, throttle)
+
                 args |= {
                     "update_modelValue": (
                         "window.delay_manager.throttle("
-                        f"  '{v_model}',"
+                        f"  '{field}',"
                         f"  () => flushState('{object_name_in_state}'),"
-                        f"  {throttle}"
+                        f"  {throttle_field}"
                         ")"
                     )
                 }
@@ -107,10 +130,10 @@ class InputField:
 
     def __new__(
         cls,
-        v_model: Optional[Union[tuple[str, Any], str]] = None,
+        v_model: Union[str, Tuple, None] = None,
         required: bool = False,
-        debounce: int = -1,
-        throttle: int = -1,
+        debounce: Union[int, Tuple] = -1,
+        throttle: Union[int, Tuple] = -1,
         type: str = "text",
         **kwargs: Any,
     ) -> AbstractElement:
@@ -118,18 +141,19 @@ class InputField:
 
         Parameters
         ----------
-        v_model : tuple[str, Any] or str, optional
+        v_model : Union[str, Tuple], optional
             The v-model for this component. If this references a Pydantic configuration variable, then this component
             will attempt to load a label, hint, and validation rules from the configuration for you automatically.
-        required : bool
+        required : bool, optional
             If true, the input will be visually marked as required and a required rule will be added to the end of the
-            rules list.
-        debounce : int
+            rules list. This parameter will be removed in the future. Please use Pydantic to enforce validation of
+            required fields.
+        debounce : Union[int, Tuple], optional
             Number of milliseconds to wait after the last user interaction with this field before attempting to update
             the Trame state. If set to 0, then no debouncing will occur. If set to -1, then the environment variable
             `NOVA_TRAME_DEFAULT_DEBOUNCE` will be used to set this (defaults to 0). See the `Lodash Docs
             <https://lodash.com/docs/4.17.15#debounce>`__ for details.
-        throttle : int
+        throttle : Union[int, Tuple], optional
             Number of milliseconds to wait between updates to the Trame state when the user is interacting with this
             field. If set to 0, then no throttling will occur. If set to -1, then the environment variable
             `NOVA_TRAME_DEFAULT_THROTTLE` will be used to set this (defaults to 0). See the `Lodash Docs
@@ -165,7 +189,9 @@ class InputField:
             - switch
             - textarea
 
-            Any other value will produce a text field with your type used as an HTML input type attribute.
+            Any other value will produce a text field with your type used as an HTML input type attribute. Note that
+            parameter does not support binding since swapping field types dynamically produces a confusing user
+            experience.
         **kwargs
             All other arguments will be passed to the underlying
             `Trame Vuetify component <https://trame.readthedocs.io/en/latest/trame.widgets.vuetify3.html>`_.
@@ -184,7 +210,10 @@ class InputField:
         """
         server = get_server(None, client_type="vue3")
 
-        kwargs = {**cls.create_boilerplate_properties(v_model, type, debounce, throttle), **kwargs}
+        kwargs = {
+            **cls.create_boilerplate_properties(v_model, type, debounce, throttle),
+            **kwargs,
+        }
 
         if "__events" not in kwargs or kwargs["__events"] is None:
             kwargs["__events"] = []

nova/trame/view/components/remote_file_input.py

@@ -2,14 +2,17 @@
 
 from functools import partial
 from tempfile import NamedTemporaryFile
-from typing import Any, Optional, Union, cast
+from typing import Any, List, Optional, Tuple, Union, cast
 
 from trame.app import get_server
 from trame.widgets import client, html
 from trame.widgets import vuetify3 as vuetify
 from trame_client.widgets.core import AbstractElement
+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_name, set_state_param
 from nova.trame.model.remote_file_input import RemoteFileInputModel
 from nova.trame.view_model.remote_file_input import RemoteFileInputViewModel
 
@@ -24,57 +27,47 @@ class RemoteFileInput:
 
     def __init__(
         self,
-        v_model: Optional[Union[tuple[str, Any], str]] = None,
-        allow_files: bool = True,
-        allow_folders: bool = False,
-        allow_nonexistent_path: bool = False,
-        base_paths: Optional[list[str]] = None,
+        v_model: Union[str, Tuple],
+        allow_files: Union[bool, Tuple] = True,
+        allow_folders: Union[bool, Tuple] = False,
+        base_paths: Union[List[str], Tuple, None] = None,
         dialog_props: Optional[dict[str, Any]] = None,
-        extensions: Optional[list[str]] = None,
+        extensions: Union[List[str], Tuple, None] = None,
         input_props: Optional[dict[str, Any]] = None,
-        return_contents: bool = False,
+        return_contents: Union[bool, Tuple] = False,
     ) -> None:
         """Constructor for RemoteFileInput.
 
         Parameters
         ----------
-        v_model : tuple[str, Any] or str, optional
+        v_model : Union[str, Tuple]
             The v-model for this component. If this references a Pydantic configuration variable, then this component
             will attempt to load a label, hint, and validation rules from the configuration for you automatically.
-        allow_files : bool
+        allow_files : Union[bool, Tuple], optional
             If true, the user can save a file selection.
-        allow_folders : bool
+        allow_folders : Union[bool, Tuple], optional
             If true, the user can save a folder selection.
-        allow_nonexistent_path : bool
-            If false, the user will be warned when they've selected a non-existent path on the filesystem.
-        base_paths : list[str], optional
+        base_paths : Union[List[str], Tuple], optional
             Only files under these paths will be shown.
-        dialog_props : dict[str, typing.Any], optional
+        dialog_props : Dict[str, typing.Any], optional
             Props to be passed to VDialog.
-        extensions : list[str], optional
+        extensions : Union[List[str], Tuple], optional
             Only files with these extensions will be shown by default. The user can still choose to view all files.
-        input_props : dict[str, typing.Any], optional
+        input_props : Dict[str, typing.Any], optional
             Props to be passed to InputField.
-        return_contents : bool
+        return_contents : Union[bool, Tuple], optional
             If true, then the v_model will contain the contents of the file. If false, then the v_model will contain the
-            path of the file.
-
-        Raises
-        ------
-        ValueError
-            If v_model is None.
+            path of the file. Defaults to false.
 
         Returns
         -------
         None
         """
-        if v_model is None:
-            raise ValueError("RemoteFileInput must have a v_model attribute.")
+        self.server = get_server(None, client_type="vue3")
 
         self.v_model = v_model
         self.allow_files = allow_files
         self.allow_folders = allow_folders
-        self.allow_nonexistent_path = allow_nonexistent_path
         self.base_paths = base_paths if base_paths else ["/"]
         self.dialog_props = dict(dialog_props) if dialog_props else {}
         self.extensions = extensions if extensions else []
@@ -88,10 +81,16 @@ class RemoteFileInput:
         if "width" not in self.dialog_props:
             self.dialog_props["width"] = 600
 
-        self.create_model()
-        self.create_viewmodel()
+        self._create_model()
+        self._create_viewmodel()
+        self._setup_bindings()
+
         self.create_ui()
 
+    @property
+    def state(self) -> State:
+        return self.server.state
+
     def create_ui(self) -> None:
         with cast(
             AbstractElement,
@@ -175,12 +174,11 @@ class RemoteFileInput:
                                     click=partial(self.vm.close_dialog, cancel=True),
                                 )
 
-    def create_model(self) -> None:
-        self.model = RemoteFileInputModel(self.allow_files, self.allow_folders, self.base_paths, self.extensions)
+    def _create_model(self) -> None:
+        self.model = RemoteFileInputModel()
 
-    def create_viewmodel(self) -> None:
-        server = get_server(None, client_type="vue3")
-        binding = TrameBinding(server.state)
+    def _create_viewmodel(self) -> None:
+        binding = TrameBinding(self.state)
 
         if isinstance(self.v_model, tuple):
             model_name = self.v_model[0]
@@ -197,12 +195,91 @@ class RemoteFileInput:
         self.vm.file_list_bind.connect(self.vm.get_file_list_state_name())
         self.vm.filter_bind.connect(self.vm.get_filter_state_name())
         self.vm.on_close_bind.connect(client.JSEval(exec=f"{self.vm.get_dialog_state_name()} = false;").exec)
-        if self.return_contents:
+        self.vm.showing_all_bind.connect(self.vm.get_showing_all_state_name())
+        self.vm.valid_selection_bind.connect(self.vm.get_valid_selection_state_name())
+
+    # 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.
+        self._last_allow_files = set_state_param(self.state, self.allow_files)
+        self._last_allow_folders = set_state_param(self.state, self.allow_folders)
+        self._last_base_paths = set_state_param(self.state, self.base_paths)
+        self._last_extensions = set_state_param(self.state, self.extensions)
+        self._last_return_contents = set_state_param(self.state, self.return_contents)
+
+        # Now we need to propagate the state to this component's view model.
+        self.vm.set_binding_parameters(
+            allow_files=self.allow_files,
+            allow_folders=self.allow_folders,
+            base_paths=self.base_paths,
+            extensions=self.extensions,
+        )
+        self._setup_update_binding(self._last_return_contents)
+
+        # 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.allow_files, tuple):
+
+            @self.state.change(get_state_name(self.allow_files[0]))
+            def on_allow_files_change(**kwargs: Any) -> None:
+                if isinstance(self.allow_files, bool):
+                    return
+                allow_files = rgetdictvalue(kwargs, self.allow_files[0])
+                if allow_files != self._last_allow_files:
+                    self.vm.set_binding_parameters(
+                        allow_files=set_state_param(self.state, self.allow_files, allow_files)
+                    )
+
+        if isinstance(self.allow_folders, tuple):
+
+            @self.state.change(get_state_name(self.allow_folders[0]))
+            def on_allow_folders_change(**kwargs: Any) -> None:
+                if isinstance(self.allow_folders, bool):
+                    return
+                allow_folders = rgetdictvalue(kwargs, self.allow_folders[0])
+                if allow_folders != self._last_allow_folders:
+                    self.vm.set_binding_parameters(
+                        allow_folders=set_state_param(self.state, self.allow_folders, allow_folders)
+                    )
+
+        if isinstance(self.base_paths, tuple):
+
+            @self.state.change(get_state_name(self.base_paths[0]))
+            def on_base_paths_change(**kwargs: Any) -> None:
+                if isinstance(self.base_paths, bool):
+                    return
+                base_paths = rgetdictvalue(kwargs, self.base_paths[0])
+                if base_paths != self._last_base_paths:
+                    self.vm.set_binding_parameters(base_paths=set_state_param(self.state, self.base_paths, base_paths))
+
+        if isinstance(self.extensions, tuple):
+
+            @self.state.change(get_state_name(self.extensions[0]))
+            def on_extensions_change(**kwargs: Any) -> None:
+                if isinstance(self.extensions, bool):
+                    return
+                extensions = rgetdictvalue(kwargs, self.extensions[0])
+                if extensions != self._last_extensions:
+                    self.vm.set_binding_parameters(extensions=set_state_param(self.state, self.extensions, extensions))
+
+        if isinstance(self.return_contents, tuple):
+
+            @self.state.change(get_state_name(self.return_contents[0]))
+            def on_return_contents_change(**kwargs: Any) -> None:
+                if isinstance(self.return_contents, bool):
+                    return
+                return_contents = rgetdictvalue(kwargs, self.return_contents[0])
+                if return_contents != self._last_return_contents:
+                    self._setup_update_binding(return_contents)
+
+    def _setup_update_binding(self, read_file: bool) -> None:
+        self.vm.reset_update_binding()
+        if read_file:
             self.vm.on_update_bind.connect(self.read_file)
         else:
             self.vm.on_update_bind.connect(self.set_v_model)
-        self.vm.showing_all_bind.connect(self.vm.get_showing_all_state_name())
-        self.vm.valid_selection_bind.connect(self.vm.get_valid_selection_state_name())
 
     def read_file(self, file_path: str) -> None:
         with open(file_path, mode="rb") as file:

nova/trame/view/theme/assets/js/delay_manager.js

@@ -5,19 +5,25 @@ class DelayManager {
     }
 
     debounce(id, func, wait, ...args) {
-        if (!(id in this.debounces)) {
-            this.debounces[id] = _.debounce(func, wait)
+        if (!(id in this.debounces) || this.debounces[id]['wait'] !== wait) {
+            this.debounces[id] = {
+                'debounce': _.debounce(func, wait),
+                'wait': wait
+            }
         }
 
-        this.debounces[id](...args)
+        this.debounces[id]['debounce'](...args)
     }
 
     throttle(id, func, wait, ...args) {
-        if (!(id in this.throttles)) {
-            this.throttles[id] = _.throttle(func, wait)
+        if (!(id in this.throttles) || this.throttles[id]['wait'] !== wait) {
+            this.throttles[id] = {
+                'throttle': _.throttle(func, wait),
+                'wait': wait
+            }
         }
 
-        this.throttles[id](...args)
+        this.throttles[id]['throttle'](...args)
     }
 }
 

nova/trame/view_model/remote_file_input.py

@@ -14,6 +14,7 @@ class RemoteFileInputViewModel:
     def __init__(self, model: RemoteFileInputModel, binding: BindingInterface) -> None:
         """Creates a new RemoteFileInputViewModel."""
         self.model = model
+        self.binding = binding
 
         # Needed to keep state variables separated if this class is instantiated multiple times.
         self.id = RemoteFileInputViewModel.counter
@@ -23,13 +24,16 @@ class RemoteFileInputViewModel:
         self.showing_base_paths = True
         self.previous_value = ""
         self.value = ""
-        self.dialog_bind = binding.new_bind()
-        self.file_list_bind = binding.new_bind()
-        self.filter_bind = binding.new_bind()
-        self.showing_all_bind = binding.new_bind()
-        self.valid_selection_bind = binding.new_bind()
-        self.on_close_bind = binding.new_bind()
-        self.on_update_bind = binding.new_bind()
+        self.dialog_bind = self.binding.new_bind()
+        self.file_list_bind = self.binding.new_bind()
+        self.filter_bind = self.binding.new_bind()
+        self.showing_all_bind = self.binding.new_bind()
+        self.valid_selection_bind = self.binding.new_bind()
+        self.on_close_bind = self.binding.new_bind()
+        self.on_update_bind = self.binding.new_bind()
+
+    def reset_update_binding(self) -> None:
+        self.on_update_bind = self.binding.new_bind()
 
     def open_dialog(self) -> None:
         self.previous_value = self.value
@@ -93,3 +97,6 @@ class RemoteFileInputViewModel:
 
         self.valid_selection_bind.update_in_view(self.model.valid_selection(new_path))
         self.populate_file_list()
+
+    def set_binding_parameters(self, **kwargs: Any) -> None:
+        self.model.set_binding_parameters(**kwargs)

{nova_trame-0.25.3.dist-info → nova_trame-0.25.4.dist-info}/METADATA

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

{nova_trame-0.25.3.dist-info → nova_trame-0.25.4.dist-info}/RECORD

@@ -3,16 +3,16 @@ nova/trame/__init__.py,sha256=gFrAg1qva5PIqR5TjvPzAxLx103IKipJLqp3XXvrQL8,59
 nova/trame/_internal/utils.py,sha256=lTTJnfqbbIe21Tg2buf5MXqKUEUop7Va5PZgpWMzRkI,1381
 nova/trame/model/data_selector.py,sha256=rDmWDtHVGgi5e2fBEYvChM2vVKNu798m67Sq8MUN2UI,4463
 nova/trame/model/ornl/neutron_data_selector.py,sha256=Nkj0DXdv3ydfXV3zeilbOGWuRCVzc_ClAOj6iNnN0uI,6276
-nova/trame/model/remote_file_input.py,sha256=9KAf31ZHzpsh_aXUrNcF81Q5jvUZDWCzW1QATKls-Jk,3675
+nova/trame/model/remote_file_input.py,sha256=eAk7ZsFgNKcnpJ6KmOQDhiI6pPZpcrr1GMKkRLEWht8,4338
 nova/trame/view/components/__init__.py,sha256=60BeS69aOrFnkptjuD17rfPE1f4Z35iBH56TRmW5MW8,451
 nova/trame/view/components/data_selector.py,sha256=XFwIuKhIeBbkqsNEkIFDhjdDD5PD6cvbgn1jkivUhC4,14817
 nova/trame/view/components/execution_buttons.py,sha256=Br6uAmE5bY67TTYc5ZTHECNJ_RJqKmv17HAKPpQtbeg,4576
-nova/trame/view/components/file_upload.py,sha256=Q3t7TUJ8w6wlEqb1mnJ23yBsM1XmQPtm0awaoBrlLXo,3509
-nova/trame/view/components/input_field.py,sha256=Rtcl_eszvhgyC1rhTI7OMSLHjrE7DNH44eY08k7UXks,16094
+nova/trame/view/components/file_upload.py,sha256=nRYwTPOzJV_TCtjk337PbeRbbIOf2PipaGKOyj0WKiA,4288
+nova/trame/view/components/input_field.py,sha256=xzCmNEoB4ljGx99-gGgTV0UwriwtS8ce22zPA4QneZw,17372
 nova/trame/view/components/ornl/__init__.py,sha256=HnxzzSsxw0vQSDCVFfWsAxx1n3HnU37LMuQkfiewmSU,90
 nova/trame/view/components/ornl/neutron_data_selector.py,sha256=g633Ie3GSNu0QFEuexYl_XUxjUiGEJKjWLP7ZB5PRR0,13122
 nova/trame/view/components/progress_bar.py,sha256=zhbJwPy_HPQ8YL-ISN8sCRUQ7qY6qqo9wiV59BmvL8I,3038
-nova/trame/view/components/remote_file_input.py,sha256=6mUz6JZVhLO_Y4mZaQd_lpPe33KLtSpjxXS7uTNUmFI,10004
+nova/trame/view/components/remote_file_input.py,sha256=cXSePj_eP3lf8bRsNEHT7dp-FO3doKkW44J3_9bgPAc,14082
 nova/trame/view/components/tool_outputs.py,sha256=IbYV4VjrkWAE354Bh5KH76SPsxGLIkOXChijS4-ce_Y,2408
 nova/trame/view/components/visualization/__init__.py,sha256=reqkkbhD5uSksHHlhVMy1qNUCwSekS5HlXk6wCREYxU,152
 nova/trame/view/components/visualization/interactive_2d_plot.py,sha256=z2s1janxAclpMEdDJk3z-CQ6r3KPNoR_SXPx9ppWnuQ,3481
@@ -25,7 +25,7 @@ nova/trame/view/layouts/vbox.py,sha256=XRV14e32MY1HWc9FTVTv1vOatWWbhLMd0lYwZP-is
 nova/trame/view/theme/__init__.py,sha256=70_marDlTigIcPEOGiJb2JTs-8b2sGM5SlY7XBPtBDM,54
 nova/trame/view/theme/assets/core_style.scss,sha256=3-3qMc5gpaDhfuVWAF_psBH5alxwiuK-hPGhVgi2cW0,4335
 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/delay_manager.js,sha256=BN4OL88QsyZG4XQ1sTorHpN1rwD4GnWoVKHvl5F5ydo,776
 nova/trame/view/theme/assets/js/lodash.min.js,sha256=KCyAYJ-fsqtp_HMwbjhy6IKjlA5lrVrtWt1JdMsC57k,73016
 nova/trame/view/theme/assets/js/revo_grid.js,sha256=81s0fUo8HbHmAyWag7pW0jP796Ttb1noAPOgTJlxJss,4069
 nova/trame/view/theme/assets/vuetify_config.json,sha256=a0FSgpLYWGFlRGSMhMq61MyDFBEBwvz55G4qjkM08cs,5627
@@ -36,10 +36,10 @@ nova/trame/view_model/data_selector.py,sha256=d8qdn6Q2b5fNo5lCXi1LTRdesfmy7wErIv
 nova/trame/view_model/execution_buttons.py,sha256=MfKSp95D92EqpD48C15cBo6dLO0Yld4FeRZMJNxJf7Y,3551
 nova/trame/view_model/ornl/neutron_data_selector.py,sha256=zpwvqETPuw0sEUvv0A2sU5Ha2_BKG_3xFYSaUuixLXw,1579
 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/remote_file_input.py,sha256=zWOflmCDJYYR_pacHphwzricV667GSRokh-mlxpBAOo,3646
 nova/trame/view_model/tool_outputs.py,sha256=ev6LY7fJ0H2xAJn9f5ww28c8Kpom2SYc2FbvFcoN4zg,829
-nova_trame-0.25.3.dist-info/LICENSE,sha256=Iu5QiDbwNbREg75iYaxIJ_V-zppuv4QFuBhAW-qiAlM,1061
-nova_trame-0.25.3.dist-info/METADATA,sha256=fUOB8LAzrU6ZyuLaEwTISI81BTrr-JbSQC7gX1e0eZo,1727
-nova_trame-0.25.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-nova_trame-0.25.3.dist-info/entry_points.txt,sha256=J2AmeSwiTYZ4ZqHHp9HO6v4MaYQTTBPbNh6WtoqOT58,42
-nova_trame-0.25.3.dist-info/RECORD,,
+nova_trame-0.25.4.dist-info/LICENSE,sha256=Iu5QiDbwNbREg75iYaxIJ_V-zppuv4QFuBhAW-qiAlM,1061
+nova_trame-0.25.4.dist-info/METADATA,sha256=WBxmym5PqxTIrvWt3kFC-LFofiAkYsdltjWN3X7iPa4,1727
+nova_trame-0.25.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+nova_trame-0.25.4.dist-info/entry_points.txt,sha256=J2AmeSwiTYZ4ZqHHp9HO6v4MaYQTTBPbNh6WtoqOT58,42
+nova_trame-0.25.4.dist-info/RECORD,,