nova-trame 0.13.1__py3-none-any.whl

nova/trame/view/theme/theme.py

@@ -0,0 +1,262 @@
+"""Implementation of ThemedApp."""
+
+import json
+import logging
+from asyncio import create_task
+from functools import partial
+from pathlib import Path
+from typing import Optional
+
+import sass
+from mergedeep import Strategy, merge
+from trame.app import get_server
+from trame.assets.local import LocalFileManager
+from trame.ui.vuetify3 import VAppLayout
+from trame.widgets import client
+from trame.widgets import vuetify3 as vuetify
+from trame_client.widgets import html
+from trame_server.core import Server
+from trame_server.state import State
+
+from nova.mvvm.pydantic_utils import validate_pydantic_parameter
+from nova.trame.view.utilities.local_storage import LocalStorageManager
+
+THEME_PATH = Path(__file__).parent
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+class ThemedApp:
+    """Automatically injects theming into your Trame application.
+
+    You should always inherit from this class when you define your Trame application.
+
+    Currently, it supports two themes:
+
+    1. ModernTheme - The recommended theme for most applications. Leverages ORNL brand colors and a typical Vuetify \
+    appearance.
+    2. CompactTheme - Similar to ModernTheme but with a smaller global font size and reduced margins and paddings on \
+    all components.
+    """
+
+    def __init__(
+        self, layout: str = "default", server: Server = None, vuetify_config_overrides: Optional[dict] = None
+    ) -> None:
+        """Constructor for the ThemedApp class.
+
+        Parameters
+        ----------
+        layout : str
+            The layout to use. Current options are: :code:`default` and :code:`two-column`
+        server : `trame_server.core.Server \
+            <https://trame.readthedocs.io/en/latest/core.server.html#trame_server.core.Server>`_, optional
+            The Trame server to use. If not provided, a new server will be created.
+        vuetify_config_overrides : dict, optional
+            `Vuetify Configuration <https://vuetifyjs.com/en/features/global-configuration/>`__
+            that will override anything set in our default configuration. You should only use this if you don't want to
+            use one of our predefined themes. If you just want to set your color palette without providing a full
+            Vuetify configuration, then you can set use the following to only set the color palette used by our
+            :code:`ModernTheme`:
+
+            .. code-block:: json
+
+                {
+                    "primary": "#f00",
+                    "secondary": "#0f0",
+                    "accent": "#00f",
+                }
+
+        Returns
+        -------
+        None
+        """
+        self.server = get_server(server, client_type="vue3")
+        self.local_storage: Optional[LocalStorageManager] = None
+        if vuetify_config_overrides is None:
+            vuetify_config_overrides = {}
+
+        self.css = None
+        try:
+            with open(THEME_PATH / "assets" / "core_style.scss", "r") as scss_file:
+                self.css = sass.compile(string=scss_file.read())
+        except Exception as e:
+            logger.warning("Could not load base scss stylesheet.")
+            logger.error(e)
+
+        theme_path = THEME_PATH / "assets" / "vuetify_config.json"
+        try:
+            with open(theme_path, "r") as vuetify_config:
+                self.vuetify_config = json.load(vuetify_config)
+
+                merge(
+                    self.vuetify_config,
+                    vuetify_config_overrides,
+                    strategy=Strategy.REPLACE,
+                )
+        except Exception as e:
+            logger.warning(f"Could not load vuetify config from {theme_path}.")
+            logger.error(e)
+        for shortcut in ["primary", "secondary", "accent"]:
+            if shortcut in self.vuetify_config:
+                self.vuetify_config["theme"]["themes"]["ModernTheme"]["colors"][shortcut] = self.vuetify_config[
+                    shortcut
+                ]
+
+        # Since this is only intended for theming Trame apps, I don't think we need to invoke the MVVM framework here,
+        # and working directly with the Trame state makes this easier for me to manage.
+        self.state.nova__menu = False
+        self.state.nova__defaults = self.vuetify_config["theme"]["themes"]["ModernTheme"].get("defaults", {})
+        self.state.nova__theme = "ModernTheme"
+        self.state.trame__favicon = LocalFileManager(__file__).url("favicon", "./assets/favicon.png")
+
+    @property
+    def state(self) -> State:
+        return self.server.state
+
+    def init_mantid(self) -> None:
+        """Initializes MantidManager.
+
+        This doesn't happen by default because Mantid is a large dependency.
+        """
+        pass
+
+    async def _init_theme(self) -> None:
+        if self.local_storage:
+            theme = await self.local_storage.get("nova__theme")
+            if theme and theme in self.vuetify_config["theme"]["themes"]:
+                self.set_theme(theme, False)
+
+    async def init_theme(self) -> None:
+        create_task(self._init_theme())
+
+    def set_theme(self, theme: Optional[str], force: bool = True) -> None:
+        """Sets the theme of the application.
+
+        Parameters
+        ----------
+        theme : str, optional
+            The new theme to use. If the theme is not found, the default theme will be used.
+        force : bool, optional
+            If True, the theme will be set even if the theme selection menu is disabled.
+
+        Returns
+        -------
+        None
+        """
+        if theme not in self.vuetify_config["theme"]["themes"]:
+            raise ValueError(
+                f"Theme '{theme}' not found in the Vuetify configuration. "
+                "For a list of available themes, please visit "
+                "https://nova-application-development.readthedocs.io/en/stable/api.html#nova.trame.ThemedApp."
+            )
+
+        # I set force to True by default as I want the user to be able to say self.set_theme('MyTheme')
+        # while still blocking theme.py calls to set_theme if the selection menu is disabled.
+        if self.state.nova__menu or force:
+            with self.state:
+                self.state.nova__defaults = self.vuetify_config["theme"]["themes"].get(theme, {}).get("defaults", {})
+                self.state.nova__theme = theme
+
+        # We only want to sync to localStorage if the user is selecting and we want to preserve the selection.
+        if self.state.nova__menu and self.local_storage:
+            self.local_storage.set("nova__theme", theme)
+
+    def create_ui(self) -> VAppLayout:
+        """Creates the base UI into which you will inject your content.
+
+        You should always call this method from your application class that inherits from :code:`ThemedApp`.
+
+        Returns
+        -------
+        `trame_client.ui.core.AbstractLayout <https://trame.readthedocs.io/en/latest/core.ui.html#trame_client.ui.core.AbstractLayout>`_
+        """
+        with VAppLayout(self.server, vuetify_config=self.vuetify_config) as layout:
+            self.local_storage = LocalStorageManager(self.server.controller)
+
+            client.ClientTriggers(mounted=self.init_theme)
+            client.Style(self.css)
+
+            with vuetify.VDefaultsProvider(defaults=("nova__defaults",)) as defaults:
+                layout.defaults = defaults
+
+                with vuetify.VThemeProvider(theme=("nova__theme",)) as theme:
+                    layout.theme = theme
+
+                    with vuetify.VAppBar() as toolbar:
+                        layout.toolbar = toolbar
+
+                        with vuetify.VAppBarTitle() as toolbar_title:
+                            layout.toolbar_title = toolbar_title
+                        vuetify.VSpacer()
+                        with html.Div(classes="mr-2") as actions:
+                            layout.actions = actions
+
+                            with vuetify.VMenu(
+                                v_if="nova__menu",
+                                close_delay=10000,
+                                open_on_hover=True,
+                            ) as theme_menu:
+                                layout.theme_menu = theme_menu
+
+                                with vuetify.Template(v_slot_activator="{ props }"):
+                                    vuetify.VBtn(
+                                        v_bind="props",
+                                        classes="mr-2",
+                                        icon="mdi-brush-variant",
+                                    )
+
+                                with vuetify.VList(width=200):
+                                    vuetify.VListSubheader("Select Theme")
+                                    vuetify.VDivider()
+
+                                    for theme in self.vuetify_config.get("theme", {}).get("themes", {}).values():
+                                        with vuetify.VListItem(click=partial(self.set_theme, theme["value"])):
+                                            vuetify.VListItemTitle(theme["title"])
+                                            vuetify.VListItemSubtitle(
+                                                "Selected",
+                                                v_if=f"nova__theme === '{theme['value']}'",
+                                            )
+
+                    with vuetify.VMain(classes="align-stretch d-flex flex-column h-screen"):
+                        # [slot override example]
+                        layout.pre_content = vuetify.VSheet(classes="bg-background ")
+                        # [slot override example complete]
+                        with vuetify.VContainer(classes="flex-1-1 overflow-hidden pt-0 pb-0", fluid=True):
+                            layout.content = html.Div(classes="h-100 overflow-y-auto pb-1 ")
+                        layout.post_content = vuetify.VSheet(classes="bg-background ")
+
+                    with vuetify.VFooter(
+                        app=True,
+                        classes="my-0 px-1 py-0 text-center justify-center",
+                        border=True,
+                    ) as footer:
+                        layout.footer = footer
+
+                        vuetify.VProgressCircular(
+                            classes="mr-1",
+                            color="primary",
+                            indeterminate=("!!galaxy_running",),
+                            size=16,
+                            width=3,
+                        )
+                        html.A(
+                            "Powered by Calvera",
+                            classes="text-grey-lighten-1 text-caption text-decoration-none",
+                            href=("galaxy_url",),
+                            target="_blank",
+                        )
+                        vuetify.VSpacer()
+                        footer.add_child(
+                            '<a href="https://www.ornl.gov/" '
+                            'class="text-grey-lighten-1 text-caption text-decoration-none" '
+                            'target="_blank">© 2024 ORNL</a>'
+                        )
+
+            @self.server.controller.trigger("validate_pydantic_field")
+            def validate_pydantic_field(name: str, value: str, index: int) -> bool:
+                if "[index]" in name:
+                    name = name.replace("[index]", f"[{str(index)}]")
+                return validate_pydantic_parameter(name, value)
+
+            return layout

nova/trame/view/utilities/local_storage.py

@@ -0,0 +1,102 @@
+"""Implementation of LocalStorageManager."""
+
+from asyncio import sleep
+from typing import Any, Optional
+
+from trame.widgets import client
+from trame_server.core import Controller
+
+
+class LocalStorageManager:
+    """Allows manipulation of window.localStorage from your Python code.
+
+    LocalStorageManager requires a Trame layout to exist in order to work properly. Because of this, it's strongly
+    recommended that you don't use this class directly. Instead, ThemedApp automatically creates an instance of this
+    class and stores it in ThemedApp.local_storage, through which it can safely be used.
+    """
+
+    def __init__(self, ctrl: Controller) -> None:
+        """Constructor for the LocalStorageManager class.
+
+        Parameters
+        ----------
+        ctrl : `trame_server.core.Controller <https://trame.readthedocs.io/en/latest/core.controller.html#trame_server.controller.Controller>`_
+            The Trame controller.
+
+        Returns
+        -------
+        None
+        """
+        self.js_get = client.JSEval(
+            exec=(
+                "window.trame.trigger("
+                "  'nova__local_storage_trigger', "
+                "  [$event.key, window.localStorage.getItem($event.key)]"
+                ");"
+            )
+        ).exec
+        self.js_remove = client.JSEval(exec="window.localStorage.removeItem($event.key);").exec
+        self.js_set = client.JSEval(exec="window.localStorage.setItem($event.key, $event.value);").exec
+
+        self._ready: dict[str, bool] = {}
+        self._values: dict[str, str] = {}
+
+        @ctrl.trigger("nova__local_storage_trigger")
+        def _(key: str, value: str) -> None:
+            self._ready[key] = True
+            self._values[key] = value
+
+    async def get(self, key: str) -> Optional[str]:
+        """Gets the value of a key from window.localStorage.
+
+        You cannot call this from the main Trame coroutine because this waits on a response from the browser that must
+        be processed by the main coroutine. Instead, you should call this from another thread or coroutine, typically
+        with :code:`asyncio.create_task`.
+
+        Parameters
+        ----------
+        key : str
+            The key to get the value of.
+
+        Returns
+        -------
+        Optional[str]
+            The value of the key from window.localStorage.
+        """
+        self._ready[key] = False
+        self.js_get({"key": key})
+
+        while not self._ready[key]:
+            await sleep(0.1)
+
+        return self._values[key]
+
+    def remove(self, key: str) -> None:
+        """Removes a key from window.localStorage.
+
+        Parameters
+        ----------
+        key : str
+            The key to remove.
+
+        Returns
+        -------
+        None
+        """
+        self.js_remove({"key": key})
+
+    def set(self, key: str, value: Any) -> None:
+        """Sets the value of a key in window.localStorage.
+
+        Parameters
+        ----------
+        key : str
+            The key to set the value of.
+        value : typing.Any
+            The value to set. This value will be coerced to a string before being stored.
+
+        Returns
+        -------
+        None
+        """
+        self.js_set({"key": key, "value": value})

nova/trame/view_model/remote_file_input.py

@@ -0,0 +1,93 @@
+"""View model for RemoteFileInput."""
+
+from typing import Any, Union
+
+from nova.mvvm.interface import BindingInterface
+from nova.trame.model.remote_file_input import RemoteFileInputModel
+
+
+class RemoteFileInputViewModel:
+    """Manages the view state of RemoteFileInput."""
+
+    counter = 0
+
+    def __init__(self, model: RemoteFileInputModel, binding: BindingInterface) -> None:
+        """Creates a new RemoteFileInputViewModel."""
+        self.model = model
+
+        # Needed to keep state variables separated if this class is instantiated multiple times.
+        self.id = RemoteFileInputViewModel.counter
+        RemoteFileInputViewModel.counter += 1
+
+        self.showing_all_files = False
+        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()
+
+    def open_dialog(self) -> None:
+        self.previous_value = self.value
+        self.populate_file_list()
+
+    def close_dialog(self, cancel: bool = False) -> None:
+        if not cancel:
+            self.on_update_bind.update_in_view(self.value)
+        else:
+            self.value = self.previous_value
+
+        self.filter_bind.update_in_view(self.value)
+        self.on_close_bind.update_in_view(None)
+
+    def filter_paths(self, filter: str) -> None:
+        self.populate_file_list(filter)
+
+    def get_dialog_state_name(self) -> str:
+        return f"nova__dialog_{self.id}"
+
+    def get_file_list_state_name(self) -> str:
+        return f"nova__file_list_{self.id}"
+
+    def get_filter_state_name(self) -> str:
+        return f"nova__filter_{self.id}"
+
+    def get_showing_all_state_name(self) -> str:
+        return f"nova__showing_all_{self.id}"
+
+    def get_valid_selection_state_name(self) -> str:
+        return f"nova__valid_selection_{self.id}"
+
+    def init_view(self) -> None:
+        self.dialog_bind.update_in_view(False)
+        self.valid_selection_bind.update_in_view(False)
+        self.showing_all_bind.update_in_view(self.showing_all_files)
+
+    def set_value(self, value: str) -> None:
+        self.value = value
+
+    def toggle_showing_all_files(self) -> None:
+        self.showing_all_files = not self.showing_all_files
+        self.showing_all_bind.update_in_view(self.showing_all_files)
+        self.populate_file_list()
+
+    def populate_file_list(self, filter: str = "") -> None:
+        files = self.scan_current_path(filter)
+        self.file_list_bind.update_in_view(files)
+
+    def scan_current_path(self, filter: str) -> list[dict[str, Any]]:
+        files, self.showing_base_paths = self.model.scan_current_path(self.value, self.showing_all_files, filter)
+
+        return files
+
+    def select_file(self, file: Union[dict[str, str], str]) -> None:
+        new_path = self.model.select_file(file, self.value, self.showing_base_paths)
+        self.set_value(new_path)
+        self.filter_bind.update_in_view(self.value)
+
+        self.valid_selection_bind.update_in_view(self.model.valid_selection(new_path))
+        self.populate_file_list()

nova_trame-0.13.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ONRL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nova_trame-0.13.1.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.3
+Name: nova-trame
+Version: 0.13.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-email: dugganjw@ornl.gov
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: libsass
+Requires-Dist: mergedeep
+Requires-Dist: nova-mvvm
+Requires-Dist: pydantic
+Requires-Dist: tomli
+Requires-Dist: trame
+Requires-Dist: trame-vega
+Requires-Dist: trame-vuetify
+Description-Content-Type: text/markdown
+
+nova-trame
+==========
+
+`nova-trame` is a Python package for streamlining development of Trame applications used in the NOVA project.
+
+You can install this package directly with
+
+```commandline
+pip install nova-trame
+```
+
+A user guide, examples, and a full API for this package can be found at https://nova-application-development.readthedocs.io/en/stable/.
+
+Developers: please read [this document](DEVELOPMENT.md)
+

nova_trame-0.13.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+nova/__init__.py,sha256=ED6jHcYiuYpr_0vjGz0zx2lrrmJT9sDJCzIljoDfmlM,65
+nova/trame/__init__.py,sha256=gFrAg1qva5PIqR5TjvPzAxLx103IKipJLqp3XXvrQL8,59
+nova/trame/model/remote_file_input.py,sha256=9KAf31ZHzpsh_aXUrNcF81Q5jvUZDWCzW1QATKls-Jk,3675
+nova/trame/view/components/__init__.py,sha256=fopr6mVqcpDcVYK9ue7SLUHyswgvRPcFESTq86mu1R8,128
+nova/trame/view/components/input_field.py,sha256=YyDJJKHBsAdLN-GFOhXEpwNs5aJHb0BBbstcQ6nbAQE,12680
+nova/trame/view/components/remote_file_input.py,sha256=k2yrwkell_g0sGnWR9XLL1LxkmFLr8-AGhduo8E-N4A,8669
+nova/trame/view/components/visualization/__init__.py,sha256=kDX1fkbtAgXSGlqhlMNhYYoYrq-hfS636smjgLsh6gg,84
+nova/trame/view/components/visualization/interactive_2d_plot.py,sha256=foZCMoqbuahT5dtqIQvm8C4ZJcY9P211eJEcpQJltmM,3421
+nova/trame/view/layouts/__init__.py,sha256=cMrlB5YMUoK8EGB83b34UU0kPTVrH8AxsYvKRtpUNEc,141
+nova/trame/view/layouts/grid.py,sha256=k-QHuH31XeAVDuMKUMoAMVnAM-Yavq7kdLYOC1ZrGTQ,5021
+nova/trame/view/layouts/hbox.py,sha256=r5irhFX6YWTWN4V4NwNQx6mheyM8p6PVcJbrbhvOAwo,2625
+nova/trame/view/layouts/vbox.py,sha256=Q4EvrtGJORyNF6AnCLGXToy8XU6yofiO5_kt7hK-AYs,2626
+nova/trame/view/theme/__init__.py,sha256=70_marDlTigIcPEOGiJb2JTs-8b2sGM5SlY7XBPtBDM,54
+nova/trame/view/theme/assets/core_style.scss,sha256=AktysiiCYLeiTzCTtYwkksiUVmqb4S23RlDcW8L1ebI,518
+nova/trame/view/theme/assets/favicon.png,sha256=Xbp1nUmhcBDeObjsebEbEAraPDZ_M163M_ZLtm5AbQc,1927
+nova/trame/view/theme/assets/vuetify_config.json,sha256=7WGV6rO7hv2sapGsX9yy1d-dINshYFXRNX99D9I3dKQ,4780
+nova/trame/view/theme/theme.py,sha256=-5lq8u34eQ9j1bMeB5b63BiAdpi92WI2o-fJKcrwl3o,11401
+nova/trame/view/utilities/local_storage.py,sha256=vD8f2VZIpxhIKjZwEaD7siiPCTZO4cw9AfhwdawwYLY,3218
+nova/trame/view_model/remote_file_input.py,sha256=WHWCQkZBGeKLe1aTPbtVNI8tn-PDt64mi1-561uuBpQ,3320
+nova_trame-0.13.1.dist-info/LICENSE,sha256=MOqZ8tPMKy8ZETJ2-HEvFTZ7dYNlg3gXmBkV-Y9i8bw,1061
+nova_trame-0.13.1.dist-info/METADATA,sha256=ivedQKUq-ZJ2jk1e0aXkeHjbvtxXWLyOBGNl-lijv5E,1240
+nova_trame-0.13.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+nova_trame-0.13.1.dist-info/entry_points.txt,sha256=J2AmeSwiTYZ4ZqHHp9HO6v4MaYQTTBPbNh6WtoqOT58,42
+nova_trame-0.13.1.dist-info/RECORD,,

nova_trame-0.13.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.0.1
+Root-Is-Purelib: true
+Tag: py3-none-any

nova_trame-0.13.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+app=tests.gallery:main
+