solara-ui 1.31.0__py2.py3-none-any.whl → 1.32.1__py2.py3-none-any.whl

solara/__init__.py

@@ -1,6 +1,6 @@
 """Build webapps using IPywidgets"""
 
-__version__ = "1.31.0"
+__version__ = "1.32.1"
 github_url = "https://github.com/widgetti/solara"
 git_branch = "master"
 

solara/components/applayout.py

@@ -310,8 +310,12 @@ def AppLayout(
                     if title or children_appbartitle:
                         v.ToolbarTitle(children=children_appbartitle or [title])
                     v.Spacer()
-                    for child in children_appbar:
-                        solara.display(child)
+                    for i, child in enumerate(children_appbar):
+                        # if the user already provided a key, don't override it
+                        if child._key is None:
+                            solara.display(child.key(f"app-layout-appbar-user-child-{i}"))
+                        else:
+                            solara.display(child)
                     solara.Button(icon_name="mdi-fullscreen", on_click=lambda: set_fullscreen(True), icon=True, dark=False)
             with v.Row(no_gutters=False, class_="solara-content-main"):
                 v.Col(cols=12, children=children_content)

solara/components/datatable.py

@@ -11,7 +11,7 @@ import solara.hooks.dataframe
 import solara.lab
 import traitlets
 from solara.lab.hooks.dataframe import use_df_column_names
-from solara.lab.utils.dataframe import df_type
+from solara.lab.utils.dataframe import df_len, df_records, df_slice
 
 from .. import CellAction, ColumnAction
 
@@ -89,7 +89,7 @@ def DataTable(
     on_column_header_hover: Optional[Callable[[Optional[str]], None]] = None,
     column_header_info: Optional[solara.Element] = None,
 ):
-    total_length = len(df)
+    total_length = df_len(df)
     options = {"descending": False, "page": page + 1, "itemsPerPage": items_per_page, "sortBy": [], "totalItems": total_length}
     options, set_options = solara.use_state(options, key="options")
     format = format or format_default
@@ -102,19 +102,12 @@ def DataTable(
     columns = use_df_column_names(df)
 
     items = []
-    column_data = {}
-    dfs = df[i1:i2]
-
-    if df_type(df) == "pandas":
-        column_data = dfs[columns].to_dict("records")
-    elif df_type(df) == "polars":
-        column_data = dfs[columns].to_dicts()
-    else:
-        column_data = dfs[columns].to_records()
+    dfs = df_slice(df, i1, i2)
+    records = df_records(dfs)
     for i in range(i2 - i1):
         item = {"__row__": i + i1}  # special key for the row number
         for column in columns:
-            item[column] = format(dfs, column, i + i1, column_data[i][column])
+            item[column] = format(dfs, column, i + i1, records[i][column])
         items.append(item)
 
     headers = [{"text": name, "value": name, "sortable": False} for name in columns]

solara/components/markdown.py

@@ -341,34 +341,45 @@ def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict,
                 logger.exception("Error highlighting code: %s", src)
                 return repr(e)
 
-        return markdown.Markdown(  # type: ignore
-            extensions=[
-                "pymdownx.highlight",
-                "pymdownx.superfences",
-                "pymdownx.emoji",
-                "toc",  # so we get anchors for h1 h2 etc
-                "tables",
-            ],
-            extension_configs={
-                "pymdownx.emoji": {
-                    "emoji_index": _no_deep_copy_emojione,
+        if has_pymdownx:
+            return markdown.Markdown(  # type: ignore
+                extensions=[
+                    "pymdownx.highlight",
+                    "pymdownx.superfences",
+                    "pymdownx.emoji",
+                    "toc",  # so we get anchors for h1 h2 etc
+                    "tables",
+                ],
+                extension_configs={
+                    "pymdownx.emoji": {
+                        "emoji_index": _no_deep_copy_emojione,
+                    },
+                    "pymdownx.superfences": {
+                        "custom_fences": [
+                            {
+                                "name": "mermaid",
+                                "class": "mermaid",
+                                "format": pymdownx.superfences.fence_div_format,
+                            },
+                            {
+                                "name": "solara",
+                                "class": "",
+                                "format": highlight,
+                            },
+                        ],
+                    },
                 },
-                "pymdownx.superfences": {
-                    "custom_fences": [
-                        {
-                            "name": "mermaid",
-                            "class": "mermaid",
-                            "format": pymdownx.superfences.fence_div_format,
-                        },
-                        {
-                            "name": "solara",
-                            "class": "",
-                            "format": highlight,
-                        },
-                    ],
-                },
-            },
-        )
+            )
+        else:
+            logger.warning("Pymdownx not installed, using default markdown. For a better experience, install pymdownx.")
+            return markdown.Markdown(  # type: ignore
+                extensions=[
+                    "fenced_code",
+                    "codehilite",
+                    "toc",
+                    "tables",
+                ],
+            )
 
     md = solara.use_memo(make_markdown_object, dependencies=[unsafe_solara_execute])
     html = md.convert(md_text)

solara/lab/hooks/dataframe.py

@@ -1,12 +1 @@
-from ..utils.dataframe import df_type
-
-
-def use_df_column_names(df):
-    if df_type(df) == "vaex":
-        return df.get_column_names()
-    elif df_type(df) == "pandas":
-        return df.columns.tolist()
-    elif df_type(df) == "polars":
-        return df.columns
-    else:
-        raise TypeError(f"{type(df)} not supported")
+from ..utils.dataframe import df_columns as use_df_column_names  # noqa: F401

solara/lab/utils/dataframe.py

@@ -1,3 +1,6 @@
+from typing import List
+
+
 def get_pandas_major():
     import pandas as pd
 
@@ -8,6 +11,43 @@ def df_type(df):
     return df.__class__.__module__.split(".")[0]
 
 
+def df_len(df) -> int:
+    """Return the number of rows in a dataframe."""
+    return len(df)
+
+
+def df_columns(df) -> List[str]:
+    """Return a list of column names from a dataframe."""
+    if df_type(df) == "vaex":
+        return df.get_column_names()
+    elif df_type(df) == "pandas":
+        return df.columns.tolist()
+    elif df_type(df) == "polars":
+        return df.columns
+    else:
+        raise TypeError(f"{type(df)} not supported")
+
+
+def df_slice(df, start: int, stop: int):
+    """Return a subset of rows from a dataframe."""
+    if df_type(df) == "pandas":
+        return df.iloc[start:stop]
+    else:
+        return df[start:stop]
+
+
+def df_records(df) -> List[dict]:
+    """A list of records from a dataframe."""
+    if df_type(df) == "pandas":
+        return df.to_dict("records")
+    elif df_type(df) == "polars":
+        return df.to_dicts()
+    elif df_type(df) == "vaex":
+        return df.to_records()
+    else:
+        raise TypeError(f"{type(df)} not supported")
+
+
 def df_unique(df, column, limit=None):
     if df_type(df) == "vaex":
         return df.unique(column, limit=limit + 1 if limit else None, limit_raise=False)

solara/minisettings.py

@@ -1,6 +1,7 @@
+import inspect
 import os
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Optional, List, Type
 
 # similar API to pydantic/pydantic-settings but we prefer not to have a dependency on pydantic
 # since we cannot be compatible with pydantic1 and 2
@@ -61,11 +62,16 @@ class _Field:
 
 
 def convert(annotation, value: str) -> Any:
-    check_optional_types = [str, int, float, bool, Path]
-    for check_type in check_optional_types:
-        if annotation == Optional[check_type]:
-            annotation = check_type
+    check_sub_types: List[Type] = [str, int, float, bool, Path]
+    for sub_type in check_sub_types:
+        if annotation == Optional[sub_type]:
+            annotation = sub_type
             return convert(annotation, value)
+    for sub_type in check_sub_types:
+        if annotation == List[sub_type]:  # type: ignore
+            annotation = sub_type
+            values = value.split(",")
+            return [convert(sub_type, k) for k in values]
     if annotation == str:
         return value
     elif annotation == int:
@@ -120,6 +126,8 @@ class BaseSettings:
             if key == "Config":
                 continue
             if not isinstance(field, _Field):
+                if inspect.isfunction(field):
+                    continue
                 field = Field(field)
                 setattr(cls, key, field)
                 field.__set_name__(cls, key)

solara/server/flask.py

@@ -162,8 +162,8 @@ def kernels_connection(ws: simple_websocket.Server, kernel_id: str, name: str):
 @blueprint.route("/_solara/api/close/<kernel_id>", methods=["GET", "POST"])
 def close(kernel_id: str):
     page_id = request.args["session_id"]
-    if kernel_id in kernel_context.contexts:
-        context = kernel_context.contexts[kernel_id]
+    context = kernel_context.contexts.get(kernel_id, None)
+    if context is not None:
         context.page_close(page_id)
     return ""
 
@@ -184,9 +184,7 @@ def public(path):
 def assets(path):
     if not allowed():
         abort(401)
-    overrides = [app.directory.parent / "assets" for app in appmod.apps.values()]
-    default = server.solara_static.parent / "assets"
-    directories = [*overrides, default]
+    directories = server.asset_directories()
     for directory in directories:
         file = directory / path
         if file.exists():

solara/server/kernel_context.py

@@ -73,6 +73,7 @@ class VirtualKernelContext:
     _last_kernel_cull_task: "Optional[asyncio.Future[None]]" = None
     closed_event: threading.Event = dataclasses.field(default_factory=threading.Event)
     _on_close_callbacks: List[Callable[[], None]] = dataclasses.field(default_factory=list)
+    lock: threading.RLock = dataclasses.field(default_factory=threading.RLock)
 
     def __post_init__(self):
         with self:
@@ -108,14 +109,15 @@ class VirtualKernelContext:
         current_context[key] = local.kernel_context_stack.pop()
 
     def close(self):
-        if self.closed_event.is_set():
-            logger.error("Tried to close a kernel context that is already closed: %s", self.id)
-            return
-        logger.info("Shut down virtual kernel: %s", self.id)
-        with self:
+        with self, self.lock:
+            for key in self.page_status:
+                self.page_status[key] = PageStatus.CLOSED
+            if self.closed_event.is_set():
+                logger.error("Tried to close a kernel context that is already closed: %s", self.id)
+                return
+            logger.info("Shut down virtual kernel: %s", self.id)
             for f in reversed(self._on_close_callbacks):
                 f()
-        with self:
             if self.app_object is not None:
                 if isinstance(self.app_object, reacton.core._RenderContext):
                     try:
@@ -128,9 +130,9 @@ class VirtualKernelContext:
             # import gc
             # gc.collect()
             self.kernel.session.close()
-        if self.id in contexts:
-            del contexts[self.id]
-        self.closed_event.set()
+            if self.id in contexts:
+                del contexts[self.id]
+            self.closed_event.set()
 
     def _state_reset(self):
         state_directory = Path(".") / "states"
@@ -157,77 +159,125 @@ class VirtualKernelContext:
 
     def page_connect(self, page_id: str):
         logger.info("Connect page %s for kernel %s", page_id, self.id)
-        assert self.page_status.get(page_id) != PageStatus.CLOSED, "cannot connect with the same page_id after a close"
-        self.page_status[page_id] = PageStatus.CONNECTED
-        if self._last_kernel_cull_task:
-            self._last_kernel_cull_task.cancel()
-
-    def page_disconnect(self, page_id: str) -> "asyncio.Future[None]":
-        """Signal that a page has disconnected, and schedule a kernel cull if needed.
-
-        During the kernel reconnect window, we will keep the kernel alive, even if all pages have disconnected.
-
-        Returns a future that is set when the kernel cull is done.
-        The scheduled kernel cull can be cancelled when a new page connects, a new disconnect is scheduled,
-        or a page if explicitly closed.
-        """
-        logger.info("Disconnect page %s for kernel %s", page_id, self.id)
-        future: "asyncio.Future[None]" = asyncio.Future()
-        self.page_status[page_id] = PageStatus.DISCONNECTED
-        current_event_loop = asyncio.get_event_loop()
+        with self.lock:
+            if self.closed_event.is_set():
+                raise RuntimeError("Cannot connect a page to a closed kernel")
+            if page_id in self.page_status and self.page_status.get(page_id) == PageStatus.CLOSED:
+                raise RuntimeError("Cannot connect a page that is already closed")
+            self.page_status[page_id] = PageStatus.CONNECTED
+            if self._last_kernel_cull_task:
+                logger.info("Cancelling previous kernel cull task for virtual kernel %s", self.id)
+                self._last_kernel_cull_task.cancel()
 
+    def _bump_kernel_cull(self):
         async def kernel_cull():
             try:
                 cull_timeout_sleep_seconds = solara.util.parse_timedelta(solara.server.settings.kernel.cull_timeout)
                 logger.info("Scheduling kernel cull, will wait for max %s before shutting down the virtual kernel %s", cull_timeout_sleep_seconds, self.id)
                 await asyncio.sleep(cull_timeout_sleep_seconds)
-                has_connected_pages = PageStatus.CONNECTED in self.page_status.values()
-                if has_connected_pages:
-                    logger.info("We have (re)connected pages, keeping the virtual kernel %s alive", self.id)
-                else:
-                    logger.info("No connected pages, and timeout reached, shutting down virtual kernel %s", self.id)
-                    self.close()
-                current_event_loop.call_soon_threadsafe(future.set_result, None)
+                logger.info("Timeout reached, checking if we should be shutting down virtual kernel %s", self.id)
+                with self.lock:
+                    has_connected_pages = PageStatus.CONNECTED in self.page_status.values()
+                    if has_connected_pages:
+                        logger.info("We have (re)connected pages, keeping the virtual kernel %s alive", self.id)
+                    else:
+                        logger.info("No connected pages, and timeout reached, shutting down virtual kernel %s", self.id)
+                        self.close()
+                if current_event_loop is not None and future is not None:
+                    current_event_loop.call_soon_threadsafe(future.set_result, None)
             except asyncio.CancelledError:
-                if sys.version_info >= (3, 9):
-                    current_event_loop.call_soon_threadsafe(future.cancel, "cancelled because a new cull task was scheduled")
-                else:
-                    current_event_loop.call_soon_threadsafe(future.cancel)
+                if current_event_loop is not None and future is not None:
+                    if sys.version_info >= (3, 9):
+                        current_event_loop.call_soon_threadsafe(future.cancel, "cancelled because a new cull task was scheduled")
+                    else:
+                        current_event_loop.call_soon_threadsafe(future.cancel)
                 raise
 
-        has_connected_pages = PageStatus.CONNECTED in self.page_status.values()
-        if not has_connected_pages:
-            # when we have no connected pages, we will schedule a kernel cull
+        async def create_task():
+            task = asyncio.create_task(kernel_cull())
+            # create a reference to the task so we can cancel it later
+            self._last_kernel_cull_task = task
+            await task
+
+        with self.lock:
+            future: "Optional[asyncio.Future[None]]" = None
+            current_event_loop: Optional[asyncio.AbstractEventLoop] = None
+            try:
+                future = asyncio.Future()
+                current_event_loop = asyncio.get_event_loop()
+            except RuntimeError:
+                pass
             if self._last_kernel_cull_task:
+                logger.info("Cancelling previous kernel cull tas for virtual kernel %s", self.id)
                 self._last_kernel_cull_task.cancel()
 
-            async def create_task():
-                task = asyncio.create_task(kernel_cull())
-                # create a reference to the task so we can cancel it later
-                self._last_kernel_cull_task = task
-                await task
-
+            logger.info("Scheduling kernel cull for virtual kernel %s", self.id)
             asyncio.run_coroutine_threadsafe(create_task(), keep_alive_event_loop)
-        else:
-            future.set_result(None)
-        return future
+            return future
+
+    def page_disconnect(self, page_id: str) -> "Optional[asyncio.Future[None]]":
+        """Signal that a page has disconnected, and schedule a kernel cull if needed.
+
+        During the kernel reconnect window, we will keep the kernel alive, even if all pages have disconnected.
+
+        Will return a future that is set when the kernel cull is done, when an event loop is available.
+        The scheduled kernel cull can be cancelled when a new page connects, a new disconnect is scheduled,
+        or a page if explicitly closed.
+        """
+
+        logger.info("Disconnect page %s for kernel %s", page_id, self.id)
+        future: "asyncio.Future[None]" = asyncio.Future()
+        with self.lock:
+            if self.page_status[page_id] == PageStatus.CLOSED:
+                # this happens when the close beackon call happens before the websocket disconnect
+                logger.info("Page %s already closed for kernel %s", page_id, self.id)
+                future.set_result(None)
+                return future
+            assert self.page_status[page_id] == PageStatus.CONNECTED, "cannot disconnect a page that is in state: %r" % self.page_status[page_id]
+            self.page_status[page_id] = PageStatus.DISCONNECTED
+            has_connected_pages = PageStatus.CONNECTED in self.page_status.values()
+            if not has_connected_pages:
+                # when we have no connected pages, we will schedule a kernel cull
+                future = self._bump_kernel_cull()
+            else:
+                logger.info("Still have connected pages, do nothing for kernel %s", self.id)
+                future.set_result(None)
+            return future
 
     def page_close(self, page_id: str):
-        """Signal that a page has closed, and close the context if needed.
+        """Signal that a page has closed, close the context if needed and schedule a kernel cull if needed.
 
         Closing the browser tab or a page navigation means an explicit close, which is
         different from a websocket/page disconnect, which we might want to recover from.
 
         """
-        self.page_status[page_id] = PageStatus.CLOSED
-        logger.info("Close page %s for kernel %s", page_id, self.id)
-        has_connected_pages = PageStatus.CONNECTED in self.page_status.values()
-        has_disconnected_pages = PageStatus.DISCONNECTED in self.page_status.values()
-        if not (has_connected_pages or has_disconnected_pages):
-            logger.info("No connected or disconnected pages, shutting down virtual kernel %s", self.id)
-            if self._last_kernel_cull_task:
-                self._last_kernel_cull_task.cancel()
-            self.close()
+        future: "Optional[asyncio.Future[None]]" = None
+
+        try:
+            future = asyncio.Future()
+        except RuntimeError:
+            pass
+        else:
+            future.set_result(None)
+        with self.lock:
+            if self.page_status[page_id] == PageStatus.CLOSED:
+                logger.info("Page %s already closed for kernel %s", page_id, self.id)
+                return
+            self.page_status[page_id] = PageStatus.CLOSED
+            logger.info("Close page %s for kernel %s", page_id, self.id)
+            has_connected_pages = PageStatus.CONNECTED in self.page_status.values()
+            has_disconnected_pages = PageStatus.DISCONNECTED in self.page_status.values()
+            # if we have disconnected pages, we may have cancelled the kernel cull task
+            # if we still have connected pages, it will go to a disconnected state again
+            # which will also trigger a new kernel cull
+            if has_disconnected_pages:
+                future = self._bump_kernel_cull()
+            if not (has_connected_pages or has_disconnected_pages):
+                logger.info("No connected or disconnected pages, shutting down virtual kernel %s", self.id)
+                self.close()
+            else:
+                logger.info("Still have connected or disconnected pages, keeping virtual kernel %s alive", self.id)
+        return future
 
 
 try:

solara/server/server.py

@@ -258,6 +258,13 @@ def process_kernel_messages(kernel: Kernel, msg: Dict) -> bool:
         return False
 
 
+def asset_directories():
+    application = [app.directory.parent / "assets" for app in app.apps.values()]
+    extra_paths = settings.assets.extra_paths()
+    solara_assets = solara_static.parent / "assets"
+    return [*application, *extra_paths, solara_assets]
+
+
 def read_root(
     path: str,
     root_path: str = "",
@@ -292,10 +299,7 @@ def read_root(
             directories = [default_app.directory.parent / "public"]
             filename = path[len("/static/public/") :]
         elif path.startswith("/static/assets/"):
-            directories = [
-                default_app.directory.parent / "assets",
-                solara_static.parent / "assets",
-            ]
+            directories = asset_directories()
             filename = path[len("/static/assets/") :]
         elif path.startswith("/static/"):
             directories = [solara_static.parent / "static"]

solara/server/settings.py

@@ -1,4 +1,5 @@
 import os
+import importlib
 import re
 import site
 import sys
@@ -6,7 +7,7 @@ import uuid
 import warnings
 from enum import Enum
 from pathlib import Path
-from typing import Optional
+from typing import Optional, List
 
 try:
     from filelock import FileLock
@@ -79,6 +80,23 @@ class Assets(BaseSettings):
     proxy_cache_dir: Path = Path(prefix + "/share/solara/cdn/")
     fontawesome_enabled: bool = True
     fontawesome_path: str = "/font-awesome@4.5.0/css/font-awesome.min.css"
+    extra_locations: List[str] = []
+
+    def extra_paths(self) -> List[Path]:
+        # translate locations (packages, directories) into list of paths
+        paths = []
+        for location in self.extra_locations:
+            if Path(location).exists():
+                paths.append(Path(location))
+            else:
+                try:
+                    package = importlib.import_module(location)
+                except ModuleNotFoundError:
+                    raise RuntimeError(f"Could not find {location} as a file or package (SOLARA_ASSETS_EXTRA_LOCATION={self.extra_locations!r}) ")
+                if not hasattr(package, "__path__"):
+                    raise RuntimeError(f"{location} is not a package (SOLARA_ASSETS_EXTRA_LOCATION={self.extra_locations!r}) ")
+                paths.append(Path(package.__path__[0]))
+        return paths
 
     class Config:
         env_prefix = "solara_assets_"
@@ -213,3 +231,7 @@ if oauth.client_id:
         # for the test accounts, this is fine
         if session.https_only is None:
             session.https_only = False
+
+
+# call early so a misconfiguration fails early
+assets.extra_paths()

solara/server/starlette.py

@@ -311,8 +311,8 @@ async def _kernel_connection(ws: starlette.websockets.WebSocket):
 def close(request: Request):
     kernel_id = request.path_params["kernel_id"]
     page_id = request.query_params["session_id"]
-    if kernel_id in kernel_context.contexts:
-        context = kernel_context.contexts[kernel_id]
+    context = kernel_context.contexts.get(kernel_id, None)
+    if context is not None:
         context.page_close(page_id)
     response = HTMLResponse(content="", status_code=200)
     return response
@@ -439,9 +439,8 @@ class StaticAssets(StaticFilesOptionalAuth):
     ) -> List[Union[str, "os.PathLike[str]"]]:
         # we only know the .directory at runtime (after startup)
         # which means we cannot pass the directory to the StaticFiles constructor
-        overrides = [app.directory.parent / "assets" for app in appmod.apps.values()]
-        default = server.solara_static.parent / "assets"
-        return cast(List[Union[str, "os.PathLike[str]"]], [*overrides, default])
+        directories = server.asset_directories()
+        return cast(List[Union[str, "os.PathLike[str]"]], directories)
 
 
 class StaticCdn(StaticFilesOptionalAuth):

solara/server/static/main-vuetify.js

@@ -138,7 +138,9 @@ async function solaraInit(mountId, appName) {
     });
 
     window.addEventListener('solara.router', function (event) {
-        app.$data.loadingPage = true;
+        if(kernel.status == 'busy') {
+            app.$data.loadingPage = true;
+        }
     });
     kernel.statusChanged.connect(() => {
         // the first idle after a loadingPage == true (a router event)

solara/server/static/solara_bootstrap.py

@@ -119,7 +119,7 @@ async def main():
     ]
     for dep in requirements:
         await micropip.install(dep, keep_going=True)
-    await micropip.install("/wheels/solara-1.31.0-py2.py3-none-any.whl", keep_going=True)
+    await micropip.install("/wheels/solara-1.32.1-py2.py3-none-any.whl", keep_going=True)
     import solara
 
     el = solara.Warning("lala")

solara/server/templates/solara.html.j2

@@ -15,7 +15,7 @@
     {% if vue3 == True %}
     <link href="{{cdn}}/@widgetti/solara-vuetify3-app@5.0.2/dist/main{{ipywidget_major_version}}.css" rel="stylesheet" class="solara-template-css"></link>
     {% else %}
-    <link href="{{cdn}}/@widgetti/solara-vuetify-app@10.0.2/dist/main{{ipywidget_major_version}}.css" rel="stylesheet" class="solara-template-css"></link>
+    <link href="{{cdn}}/@widgetti/solara-vuetify-app@10.0.3/dist/main{{ipywidget_major_version}}.css" rel="stylesheet" class="solara-template-css"></link>
     {% endif %}
 
 
@@ -228,11 +228,11 @@
         <script src="{{cdn}}/@widgetti/solara-vuetify3-app@5.0.2/dist/solara-vuetify-app{{ipywidget_major_version}}.js"></script>
         {% endif %}
     {% else %}
-        <link href="{{cdn}}/@widgetti/solara-vuetify-app@10.0.2/dist/fonts.css" rel="stylesheet" fetchpriority="low"></link>
+        <link href="{{cdn}}/@widgetti/solara-vuetify-app@10.0.3/dist/fonts.css" rel="stylesheet" fetchpriority="low"></link>
         {% if production %}
-        <script src="{{cdn}}/@widgetti/solara-vuetify-app@10.0.2/dist/solara-vuetify-app{{ipywidget_major_version}}.min.js"></script>
+        <script src="{{cdn}}/@widgetti/solara-vuetify-app@10.0.3/dist/solara-vuetify-app{{ipywidget_major_version}}.min.js"></script>
         {% else %}
-        <script src="{{cdn}}/@widgetti/solara-vuetify-app@10.0.2/dist/solara-vuetify-app{{ipywidget_major_version}}.js"></script>
+        <script src="{{cdn}}/@widgetti/solara-vuetify-app@10.0.3/dist/solara-vuetify-app{{ipywidget_major_version}}.js"></script>
         {% endif %}
     {% endif %}
     <script>