nova-trame 0.13.1__py3-none-any.whl

nova/__init__.py

@@ -0,0 +1 @@
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

nova/trame/__init__.py

@@ -0,0 +1,3 @@
+from .view.theme import ThemedApp
+
+__all__ = ["ThemedApp"]

nova/trame/model/remote_file_input.py

@@ -0,0 +1,109 @@
+"""Model state for RemoteFileInput."""
+
+import os
+from functools import cmp_to_key
+from locale import strcoll
+from typing import Any, Union
+
+
+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:
+        """Creates a new RemoteFileInputModel."""
+        self.allow_files = allow_files
+        self.allow_folders = allow_folders
+        self.base_paths = base_paths
+        self.extensions = extensions
+
+    def get_base_paths(self) -> list[dict[str, Any]]:
+        return [{"path": base_path, "directory": True} for base_path in self.base_paths]
+
+    def scan_current_path(
+        self, current_path: str, showing_all_files: bool, filter: str
+    ) -> tuple[list[dict[str, Any]], bool]:
+        failed = False
+        filter = filter.split("/")[-1]
+
+        try:
+            if current_path and (not self.valid_subpath(current_path) or not os.path.exists(current_path)):
+                raise FileNotFoundError
+
+            files = [{"path": "..", "directory": True}]
+
+            if os.path.isdir(current_path):
+                scan_path = current_path
+            else:
+                scan_path = os.path.dirname(current_path)
+
+            for entry in os.scandir(scan_path):
+                if self.valid_entry(entry, showing_all_files) and (not filter or entry.name.startswith(filter)):
+                    files.append({"path": entry.name, "directory": entry.is_dir()})
+        except OSError:
+            files = self.get_base_paths()
+            failed = True
+
+        def _sort_files(a: dict[str, Any], b: dict[str, Any]) -> int:
+            if a["directory"] and not b["directory"]:
+                return -1
+            if b["directory"] and not a["directory"]:
+                return 1
+
+            path_a = a["path"].lower()
+            path_b = b["path"].lower()
+
+            return strcoll(path_a, path_b)
+
+        sorted_files = sorted(files, key=cmp_to_key(_sort_files))
+
+        return (sorted_files, failed)
+
+    def select_file(self, file: Union[dict[str, str], str], old_path: str, showing_base_paths: bool) -> str:
+        if file == "":
+            return ""
+
+        if isinstance(file, dict):
+            file = file["path"]
+
+        if not os.path.isdir(old_path):
+            # If the previous selection is a file, then we need to append to its parent directory
+            old_path = os.path.dirname(old_path)
+
+        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:
+                return ""
+            else:
+                return os.path.dirname(old_path)
+        else:
+            return file
+
+    def valid_entry(self, entry: os.DirEntry, showing_all_files: bool) -> bool:
+        if entry.is_dir():
+            return True
+
+        if not self.allow_files:
+            return False
+
+        return showing_all_files or not self.extensions or any(entry.name.endswith(ext) for ext in self.extensions)
+
+    def valid_selection(self, selection: str) -> bool:
+        if self.valid_subpath(selection):
+            if os.path.isdir(selection) and self.allow_folders:
+                return True
+
+            if os.path.isfile(selection) and self.allow_files:
+                return True
+
+        return False
+
+    def valid_subpath(self, subpath: str) -> bool:
+        if subpath == "":
+            return False
+
+        for base_path in self.base_paths:
+            if subpath.startswith(base_path):
+                return True
+
+        return False

nova/trame/view/components/__init__.py

@@ -0,0 +1,4 @@
+from .input_field import InputField
+from .remote_file_input import RemoteFileInput
+
+__all__ = ["InputField", "RemoteFileInput"]

nova/trame/view/components/input_field.py

@@ -0,0 +1,302 @@
+"""View Implementation for InputField."""
+
+import logging
+import re
+from typing import Any, Dict, Optional, Union
+
+from trame.app import get_server
+from trame.widgets import client
+from trame.widgets import vuetify3 as vuetify
+from trame_client.widgets.core import AbstractElement
+from trame_server.controller import Controller
+from trame_server.state import State
+
+from nova.mvvm.pydantic_utils import get_field_info
+
+logger = logging.getLogger(__name__)
+
+
+class InputField:
+    """Factory class for generating Vuetify input components."""
+
+    @staticmethod
+    def create_boilerplate_properties(v_model: Optional[Union[tuple[str, Any], str]]) -> dict:
+        if not v_model:
+            return {}
+        if isinstance(v_model, tuple):
+            field = v_model[0]
+        else:
+            field = v_model
+        object_name_in_state = field.split(".")[0]
+        field_info = None
+        try:
+            field_name = ".".join(field.split(".")[1:])
+            if "[" in field_name:
+                index_field_name = re.sub(r"\[.*?\]", "[0]", field_name)
+                field_info = get_field_info(f"{object_name_in_state}.{index_field_name}")
+                if "[" in field_name and "[index]" not in field_name:
+                    field_info = None
+                    logger.warning(
+                        f"{field}: validation ignored. We currently only "
+                        f"support single loop with index variable that should be called 'index'"
+                    )
+            else:
+                field_info = get_field_info(field)
+        except Exception as _:
+            pass
+        label = ""
+        help_dict: dict = {}
+        placeholder = None
+        if field_info:
+            label = field_info.title
+            if field_info.examples and len(field_info.examples) > 0:
+                placeholder = field_info.examples[0]
+            help_dict = {"hint": field_info.description, "placeholder": placeholder}
+
+        args: Dict[str, Any] = {}
+        if v_model:
+            args |= {
+                "v_model": v_model,
+                "label": label,
+                "help": help_dict,
+                "update_modelValue": f"flushState('{object_name_in_state}')",
+            }
+            if field_info:
+                args |= {
+                    "rules": (f"[(v) => trigger('validate_pydantic_field', ['{field}', v, index])]",),
+                }
+        return args
+
+    def __new__(
+        cls,
+        v_model: Optional[Union[tuple[str, Any], str]] = None,
+        required: bool = False,
+        type: str = "text",
+        **kwargs: Any,
+    ) -> AbstractElement:
+        """Constructor for InputField.
+
+        Parameters
+        ----------
+        v_model : tuple[str, Any] or str, 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
+            If true, the input will be visually marked as required and a required rule will be added to the end of the
+            rules list.
+        type : str
+            The type of input to create. This can be any of the following:
+
+            - autocomplete
+            - autoscroll (produces a textarea that automatically scrolls to the bottom as new content is added)
+            - checkbox
+            - combobox
+            - file
+            - input
+            - otp
+            - radio
+            - range-slider
+            - select
+            - slider
+            - switch
+            - textarea
+
+            Any other value will produce a text field with your type used as an HTML input type attribute.
+        **kwargs
+            All other arguments will be passed to the underlying
+            `Trame Vuetify component <https://trame.readthedocs.io/en/latest/trame.widgets.vuetify3.html>`_.
+            The following example would set the auto_grow and label attributes on
+            `VTextarea <https://trame.readthedocs.io/en/latest/trame.widgets.vuetify3.html#trame.widgets.vuetify3.VTextarea>`_:
+
+            .. literalinclude:: ../tests/gallery/app.py
+                :start-after: InputField kwargs example start
+                :end-before: InputField kwargs example end
+                :dedent:
+
+        Returns
+        -------
+        `trame_client.widgets.core.AbstractElement <https://trame.readthedocs.io/en/latest/core.widget.html#trame_client.widgets.core.AbstractElement>`_
+            The Vuetify input component.
+        """
+        server = get_server(None, client_type="vue3")
+
+        kwargs = {**cls.create_boilerplate_properties(v_model), **kwargs}
+
+        if "__events" not in kwargs or kwargs["__events"] is None:
+            kwargs["__events"] = []
+
+        # This must be present before each input is created or change events won't be triggered.
+        if isinstance(kwargs["__events"], list):
+            if "blur" not in kwargs["__events"]:
+                kwargs["__events"].append("blur")
+            if "change" not in kwargs["__events"]:
+                kwargs["__events"].append("change")
+            if "scroll" not in kwargs["__events"]:
+                kwargs["__events"].append("scroll")
+
+        match type:
+            case "autocomplete":
+                input = vuetify.VAutocomplete(**kwargs)
+            case "autoscroll":
+                input = vuetify.VTextarea(**kwargs)
+                cls._setup_autoscroll(server.state, input)
+            case "checkbox":
+                input = vuetify.VCheckbox(**kwargs)
+            case "combobox":
+                input = vuetify.VCombobox(**kwargs)
+            case "file":
+                input = vuetify.VFileInput(**kwargs)
+            case "input":
+                input = vuetify.VInput(**kwargs)
+            case "otp":
+                input = vuetify.VOtpInput(**kwargs)
+            case "radio":
+                input = vuetify.VRadioGroup(**kwargs)
+            case "range-slider":
+                input = vuetify.VRangeSlider(**kwargs)
+            case "select":
+                items = kwargs.pop("items", None)
+                if isinstance(items, str):
+                    items = (items,)
+
+                input = vuetify.VSelect(items=items, **kwargs)
+            case "slider":
+                input = vuetify.VSlider(**kwargs)
+            case "switch":
+                input = vuetify.VSwitch(**kwargs)
+            case "textarea":
+                input = vuetify.VTextarea(**kwargs)
+            case _:
+                input = vuetify.VTextField(type=type, **kwargs)
+
+        cls._setup_ref(input)
+        cls._setup_help(input, **kwargs)
+
+        cls._check_rules(input)
+        if required:
+            cls._setup_required_label(input)
+            cls._setup_required_rule(input)
+
+        cls._setup_event_listeners(server.controller, input)
+
+        return input
+
+    @staticmethod
+    def _check_rules(input: AbstractElement) -> None:
+        if "rules" in input._py_attr and input.rules and not isinstance(input.rules, tuple):
+            raise ValueError(f"Rules for '{input.label}' must be a tuple")
+
+    @staticmethod
+    def _setup_autoscroll(state: State, input: AbstractElement) -> None:
+        if input.v_model:
+            if "id" not in input._py_attr or input.id is None:
+                input.id = f"nova__{input._id}"
+                input.scroll = f"window.nova__autoscroll('{input.id}');"
+
+            with state:
+                if state["nova_scroll_position"] is None:
+                    state["nova_scroll_position"] = {}
+                state.nova_scroll_position[input.id] = 0
+
+            autoscroll = client.JSEval(
+                exec=(
+                    "if (window.nova__autoscroll !== undefined) {"
+                    # If the autoscroll function already exists, call it.
+                    "  window.nova__autoscroll($event);"
+                    "} else {"
+                    # Save the JS so it can be called from outside of this script (ie during a scroll event).
+                    "  window.nova__autoscroll = function(id) {"
+                    # Get the element in the browser by ID
+                    "    const element = window.document.querySelector(`#${id}`);"
+                    # If the user is at the bottom of the textarea, then we should autoscroll.
+                    "    if (element.scrollTop === window.trame.state.state.nova_scroll_position[id]) {"
+                    # Scroll to the bottom
+                    "      element.scrollTop = element.scrollHeight;"
+                    # Save the new scroll position
+                    "      window.trame.state.state.nova_scroll_position[id] = element.scrollTop;"
+                    "      flushState('nova_scroll_position');"
+                    # If the user has scrolled back to the bottom, then we should reenable scrolling.
+                    "    } else if (element.scrollTop === element.scrollHeight - element.clientHeight) {"
+                    # Save the new scroll position
+                    "      window.trame.state.state.nova_scroll_position[id] = element.scrollTop;"
+                    "      flushState('nova_scroll_position');"
+                    "    }"
+                    "  };"
+                    "  window.nova__autoscroll($event);"
+                    "}"
+                )
+            ).exec
+
+            @state.change(input.v_model)
+            def _autoscroll(**kwargs: Any) -> None:
+                autoscroll(input.id)
+
+    @staticmethod
+    def _setup_help(_input: AbstractElement, **kwargs: Any) -> None:
+        help = kwargs.get("help", None)
+        if help and isinstance(help, dict):
+            _input.hint = help.get("hint", None)
+            _input.placeholder = help.get("placeholder", None)
+
+    @staticmethod
+    def _setup_required_label(input: AbstractElement) -> None:
+        if input.label:
+            input.label = f"{input.label}*"
+        else:
+            input.label = "*"
+
+    @staticmethod
+    def _setup_ref(input: AbstractElement) -> None:
+        if "ref" not in input._py_attr or input.ref is None:
+            input.ref = f"nova__{input._id}"
+
+    @staticmethod
+    def _setup_required_rule(input: AbstractElement) -> None:
+        # The rule needs to check that 1. the input has been touched by the user, and 2. the input is not empty.
+        required_rule = (
+            f"(value) => (!window.trame.refs['{input.ref}'].touched || value?.length > 0) || 'Field is required'"
+        )
+        if "rules" in input._py_attr and input.rules:
+            # Existing rules will be in format ("[rule1, rule2]",) and we need to append to this list
+            rule_end_index = input.rules[0].rindex("]")
+            input.rules = (f"{input.rules[0][:rule_end_index]}, {required_rule}{input.rules[0][rule_end_index:]}",)
+        else:
+            input.rules = (f"[{required_rule}]",)
+
+    @staticmethod
+    def _setup_event_listeners(ctrl: Controller, input: AbstractElement) -> None:
+        base_handler = None
+        if "change" in input._py_attr and input.change is not None:
+            base_handler = input.change
+
+        # Iterate over all saved refs and perform validation if there is a value that can be validated.
+        change_handler = (
+            "Object.values(window.trame.refs).map("
+            "  (ref) => ref && typeof ref.validate === 'function' && ref.value ? ref.validate() : null"
+            ");"
+        )
+
+        # We need to coerce the developer's change handler, which could be a string, callable, or tuple containing a
+        # callable, to a single string to be compatible with our change handler.
+        if callable(base_handler):
+            base_handler = (base_handler,)
+        if isinstance(base_handler, tuple):
+
+            @ctrl.trigger(f"{input.ref}__trigger")
+            def _(*args: str, **kwargs: Any) -> None:
+                base_handler[0](*args, **kwargs)
+
+            change_handler = (
+                "trigger("
+                f"'{input.ref}__trigger', "
+                f"{base_handler[1] if len(base_handler) > 1 else []}, "
+                f"{base_handler[2] if len(base_handler) > 2 else {} }"
+                f"); {change_handler}"
+            )  # Call the developer's provided change method via a trigger, then call ours.
+        elif isinstance(base_handler, str):
+            # Call the developer's provided change JS expression, then call ours.
+            change_handler = f"{base_handler}; {change_handler}"
+
+        # The user touched the input, so we can enable the required rule.
+        input.blur = f"window.trame.refs['{input.ref}'].touched = true"
+        input.change = change_handler

nova/trame/view/components/remote_file_input.py

@@ -0,0 +1,191 @@
+"""View implementation for RemoteFileInput."""
+
+from functools import partial
+from typing import Any, Optional, 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 nova.mvvm.trame_binding import TrameBinding
+from nova.trame.model.remote_file_input import RemoteFileInputModel
+from nova.trame.view.components import InputField
+from nova.trame.view_model.remote_file_input import RemoteFileInputViewModel
+
+
+class RemoteFileInput:
+    """Generates a file selection dialog for picking files off of the server.
+
+    You cannot use typical Trame :code:`with` syntax to add children to this.
+    """
+
+    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,
+        dialog_props: Optional[dict[str, Any]] = None,
+        extensions: Optional[list[str]] = None,
+        input_props: Optional[dict[str, Any]] = None,
+    ) -> None:
+        """Constructor for RemoteFileInput.
+
+        Parameters
+        ----------
+        v_model : tuple[str, Any] or str, 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.
+        allow_files : bool
+            If true, the user can save a file selection.
+        allow_folders : bool
+            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
+            Only files under these paths will be shown.
+        dialog_props : dict[str, typing.Any], optional
+            Props to be passed to VDialog.
+        extensions : list[str], 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
+            Props to be passed to InputField.
+
+        Raises
+        ------
+        ValueError
+            If v_model is None.
+
+        Returns
+        -------
+        None
+        """
+        if v_model is None:
+            raise ValueError("RemoteFileInput must have a v_model attribute.")
+
+        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 []
+        self.input_props = dict(input_props) if input_props else {}
+
+        if "__events" not in self.input_props:
+            self.input_props["__events"] = []
+        self.input_props["__events"].append("change")
+
+        if "width" not in self.dialog_props:
+            self.dialog_props["width"] = 600
+
+        self.create_model()
+        self.create_viewmodel()
+        self.create_ui()
+
+    def create_ui(self) -> None:
+        with cast(
+            AbstractElement,
+            InputField(
+                v_model=self.v_model,
+                change=(self.vm.select_file, "[$event.target.value]"),
+                **self.input_props,
+            ),
+        ) as input:
+            self.vm.init_view()
+
+            with vuetify.Template(v_slot_append=True):
+                with vuetify.VBtn(icon=True, size="small", click=self.vm.open_dialog):
+                    vuetify.VIcon("mdi-folder-open")
+
+                    with vuetify.VDialog(
+                        v_model=self.vm.get_dialog_state_name(), activator="parent", **self.dialog_props
+                    ):
+                        with vuetify.VCard(classes="pa-4"):
+                            vuetify.VCardTitle(input.label)
+                            vuetify.VTextField(
+                                v_model=self.vm.get_filter_state_name(),
+                                classes="mb-4 px-4",
+                                label="Current Selection",
+                                __events=["change"],
+                                change=(self.vm.select_file, "[$event.target.value]"),
+                                update_modelValue=(self.vm.filter_paths, "[$event]"),
+                            )
+
+                            if self.allow_files and self.extensions:
+                                with html.Div(v_if=(f"{self.vm.get_showing_all_state_name()}",)):
+                                    vuetify.VListSubheader("All Available Files")
+                                    vuetify.VBtn(
+                                        "Don't show all",
+                                        classes="mb-4",
+                                        size="small",
+                                        click=self.vm.toggle_showing_all_files,
+                                    )
+                                with html.Div(v_else=True):
+                                    vuetify.VListSubheader(
+                                        f"Available Files with Extensions: {', '.join(self.extensions)}"
+                                    )
+                                    vuetify.VBtn(
+                                        "Show all",
+                                        classes="mb-4",
+                                        size="small",
+                                        click=self.vm.toggle_showing_all_files,
+                                    )
+                            elif self.allow_files:
+                                vuetify.VListSubheader("Available Files")
+                            else:
+                                vuetify.VListSubheader("Available Folders")
+
+                            with vuetify.VList(classes="mb-4"):
+                                self.vm.populate_file_list()
+
+                                vuetify.VListItem(
+                                    "{{ file.path }}",
+                                    v_for=f"file, index in {self.vm.get_file_list_state_name()}",
+                                    classes=(
+                                        f"index < {self.vm.get_file_list_state_name()}.length - 1 "
+                                        "? 'border-b-thin' "
+                                        ": ''",
+                                    ),
+                                    prepend_icon=("file.directory ? 'mdi-folder' : 'mdi-file'",),
+                                    click=(self.vm.select_file, "[file]"),
+                                )
+
+                            with html.Div(classes="text-center"):
+                                vuetify.VBtn(
+                                    "OK",
+                                    classes="mr-4",
+                                    disabled=(f"!{self.vm.get_valid_selection_state_name()}",),
+                                    click=self.vm.close_dialog,
+                                )
+                                vuetify.VBtn(
+                                    "Cancel",
+                                    color="lightgrey",
+                                    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_viewmodel(self) -> None:
+        server = get_server(None, client_type="vue3")
+        binding = TrameBinding(server.state)
+
+        if isinstance(self.v_model, tuple):
+            model_name = self.v_model[0]
+        else:
+            model_name = self.v_model
+
+        self.vm = RemoteFileInputViewModel(self.model, binding)
+
+        self.vm.dialog_bind.connect(self.vm.get_dialog_state_name())
+        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)
+        self.vm.on_update_bind.connect(
+            client.JSEval(exec=f"{model_name} = $event; flushState('{model_name.split('.')[0].split('[')[0]}');").exec
+        )
+        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())

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

@@ -0,0 +1,3 @@
+from .interactive_2d_plot import Interactive2DPlot
+
+__all__ = ["Interactive2DPlot"]