solara 1.24.0__py2.py3-none-any.whl → 1.25.1__py2.py3-none-any.whl

solara/server/flask.py

@@ -74,7 +74,7 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
         from anyio import to_thread
 
         try:
-            return await to_thread.run_sync(lambda: self.ws.receive())
+            return await to_thread.run_sync(lambda: self.ws.receive())  # type: ignore
         except simple_websocket.ws.ConnectionClosed:
             raise websocket.WebSocketDisconnect()
 

solara/server/kernel.py

@@ -196,7 +196,7 @@ def deserialize_binary_message(bmsg):
 SESSION_KEY = b"solara"
 
 
-class WebsocketStream(object):
+class WebsocketStream:
     def __init__(self, session, channel: str):
         self.session = session
         self.channel = channel
@@ -222,7 +222,7 @@ def send_websockets(websockets: Set[websocket.WebsocketWrapper], binary_msg):
 
 class SessionWebsocket(session.Session):
     def __init__(self, *args, **kwargs):
-        super(SessionWebsocket, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.websockets: Set[websocket.WebsocketWrapper] = set()  # map from .. msg id to websocket?
 
     def close(self):
@@ -263,7 +263,7 @@ class Kernel(ipykernel.kernelbase.Kernel):
     banner = "solara"
 
     def __init__(self):
-        super(Kernel, self).__init__()
+        super().__init__()
         self.session = SessionWebsocket(parent=self, key=SESSION_KEY)
         self.msg_queue = queue.Queue()  # type: ignore
         self.stream = self.iopub_socket = WebsocketStream(self.session, "iopub")

solara/server/patch.py

@@ -255,6 +255,8 @@ def WidgetContextAwareThread__init__(self, *args, **kwargs):
 
 
 def Thread_debug_run(self):
+    if not hasattr(self, "current_context"):
+        return Thread__run(self)
     if self.current_context:
         kernel_context.set_context_for_thread(self.current_context, self)
         shell = self.current_context.kernel.shell

solara/server/reload.py

@@ -100,7 +100,7 @@ else:
                 self.directories.add(directory)
 
         def on_modified(self, event):
-            super(WatcherWatchdog, self).on_modified(event)
+            super().on_modified(event)
             logger.debug("Watch event: %s", event)
             if not event.is_directory:
                 if event.src_path in self.files:

solara/server/server.py

@@ -35,6 +35,7 @@ vue3 = ipyvue.__version__.startswith("3")
 # first look at the project directory, then the builtin solara directory
 
 
+@solara.memoize(storage=cache_memory)
 def get_jinja_env(app_name: str) -> jinja2.Environment:
     jinja_loader = jinja2.FileSystemLoader(
         [
@@ -251,9 +252,65 @@ def read_root(path: str, root_path: str = "", render_kwargs={}, use_nbextensions
     else:
         nbextensions = []
 
+    from markupsafe import Markup
+
+    def resolve_static_path(path: str) -> Path:
+        # this solve a similar problem as the starlette and flask endpoints
+        # maybe this can be common code for all of them.
+        if path.startswith("/static/public/"):
+            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"]
+            filename = path[len("/static/assets/") :]
+        elif path.startswith("/static/"):
+            directories = [solara_static.parent / "static"]
+            filename = path[len("/static/") :]
+        else:
+            raise ValueError(f"invalid static path: {path}")
+        for directory in directories:
+            full_path = directory / filename
+            if full_path.exists():
+                return full_path
+        raise ValueError(f"static path not found: {filename} (path={path}), looked in {directories}")
+
+    def include_css(path: str) -> Markup:
+        filepath = resolve_static_path(path)
+        content, hash = solara.util.get_file_hash(filepath)
+        url = f"{root_path}{path}?v={hash}"
+        # when < 10k we embed, also when we use a url, it can be relative, which can break the url
+        embed = len(content) < 1024 * 10 and b"url" not in content
+        if embed:
+            content_utf8 = content.decode("utf-8")
+            code = f"<style>/*\npath={path}\n*/\n{content_utf8}</style>"
+        else:
+            code = f'<link rel="stylesheet" type="text/css" href="{url}">'
+        return Markup(code)
+
+    def include_js(path: str, module=False) -> Markup:
+        filepath = resolve_static_path(path)
+        content, hash = solara.util.get_file_hash(filepath)
+        content_utf8 = content.decode("utf-8")
+        url = f"{root_path}{path}?v={hash}"
+        # when < 10k we embed, but if we use currentScript, it can break things
+        embed = len(content) < 1024 * 10 and b"currentScript" not in content
+        if embed:
+            if module:
+                code = f'<script type="module">/*\npath={path}\n*/{content_utf8}</script>'
+            else:
+                code = f"<script>/*\npath={path}\n*/{content_utf8}</script>"
+        else:
+            if module:
+                code = f'<script type="module" src="{url}"></script>'
+            else:
+                code = f'<script src="{url}"></script>'
+        return Markup(code)
+
     resources = {
         "theme": "light",
         "nbextensions": nbextensions,
+        "include_css": include_css,
+        "include_js": include_js,
     }
     template: jinja2.Template = get_jinja_env(app_name="__default__").get_template(template_name)
     pre_rendered_html = ""
@@ -289,6 +346,7 @@ def read_root(path: str, root_path: str = "", render_kwargs={}, use_nbextensions
         "assets": settings.assets.dict(),
         "cdn": cdn,
         "ipywidget_major_version": ipywidgets_major,
+        "solara_version": solara.__version__,
         "platform": settings.main.platform,
         "vue3": vue3,
         "perform_check": settings.main.mode != "production" and solara.checks.should_perform_solara_check(),

solara/server/settings.py

@@ -151,6 +151,7 @@ class MainSettings(BaseSettings):
     base_url: str = ""  # e.g. https://myapp.solara.run/myapp/
     platform: str = sys.platform
     host: str = HOST_DEFAULT
+    experimental_performance: bool = False
 
     class Config:
         env_prefix = "solara_"

solara/server/starlette.py

@@ -31,6 +31,8 @@ if has_solara_enterprise and sys.version_info[:2] > (3, 6):
 else:
     has_auth_support = False
 
+import solara
+from solara.server.threaded import ServerBase
 from starlette.applications import Starlette
 from starlette.exceptions import HTTPException
 from starlette.middleware import Middleware
@@ -42,9 +44,6 @@ from starlette.routing import Mount, Route, WebSocketRoute
 from starlette.staticfiles import StaticFiles
 from starlette.types import Receive, Scope, Send
 
-import solara
-from solara.server.threaded import ServerBase
-
 from . import app as appmod
 from . import kernel_context, server, settings, telemetry, websocket
 from .cdn_helper import cdn_url_path, get_path
@@ -74,20 +73,39 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
     def __init__(self, ws: starlette.websockets.WebSocket, portal: anyio.from_thread.BlockingPortal) -> None:
         self.ws = ws
         self.portal = portal
+        self.to_send: List[Union[str, bytes]] = []
+        if settings.main.experimental_performance:
+            self.task = asyncio.ensure_future(self.process_messages_task())
+
+    async def process_messages_task(self):
+        while True:
+            await asyncio.sleep(0.05)
+            while len(self.to_send) > 0:
+                first = self.to_send.pop(0)
+                if isinstance(first, bytes):
+                    await self.ws.send_bytes(first)
+                else:
+                    await self.ws.send_text(first)
 
     def close(self):
         self.portal.call(self.ws.close)
 
     def send_text(self, data: str) -> None:
-        self.portal.call(self.ws.send_text, data)
+        if settings.main.experimental_performance:
+            self.to_send.append(data)
+        else:
+            self.portal.call(self.ws.send_bytes, data)
 
     def send_bytes(self, data: bytes) -> None:
-        self.portal.call(self.ws.send_bytes, data)
+        if settings.main.experimental_performance:
+            self.to_send.append(data)
+        else:
+            self.portal.call(self.ws.send_bytes, data)
 
     async def receive(self):
         if hasattr(self.portal, "start_task_soon"):
             # version 3+
-            fut = self.portal.start_task_soon(self.ws.receive)
+            fut = self.portal.start_task_soon(self.ws.receive)  # type: ignore
         else:
             fut = self.portal.spawn_task(self.ws.receive)  # type: ignore
 
@@ -136,7 +154,7 @@ class ServerStarlette(ServerBase):
             asyncio.set_event_loop(loop)
 
         # uvloop will trigger a: RuntimeError: There is no current event loop in thread 'fastapi-thread'
-        config = Config(self.app, host=self.host, port=self.port, **self.kwargs, loop="asyncio")
+        config = Config(self.app, host=self.host, port=self.port, **self.kwargs, access_log=False, loop="asyncio")
         self.server = Server(config=config)
         self.started.set()
         self.server.run()
@@ -150,7 +168,6 @@ async def kernel_connection(ws: starlette.websockets.WebSocket):
     session_id = ws.cookies.get(server.COOKIE_KEY_SESSION_ID)
 
     if settings.oauth.private and not has_auth_support:
-        breakpoint()
         raise RuntimeError("SOLARA_OAUTH_PRIVATE requires solara-enterprise")
     if has_auth_support and "session" in ws.scope:
         user = get_user(ws)
@@ -179,8 +196,6 @@ async def kernel_connection(ws: starlette.websockets.WebSocket):
     await ws.accept()
 
     def websocket_thread_runner(ws: starlette.websockets.WebSocket, portal: anyio.from_thread.BlockingPortal):
-        ws_wrapper = WebsocketWrapper(ws, portal)
-
         async def run():
             try:
                 assert session_id is not None
@@ -194,15 +209,18 @@ async def kernel_connection(ws: starlette.websockets.WebSocket):
                 telemetry.connection_close(session_id)
 
         # sometimes throws: RuntimeError: Already running asyncio in this thread
-        anyio.run(run)
+        anyio.run(run)  # type: ignore
 
     # this portal allows us to sync call the websocket calls from this current event loop we are in
     # each websocket however, is handled from a separate thread
     try:
         async with anyio.from_thread.BlockingPortal() as portal:
-            thread_return = anyio.to_thread.run_sync(websocket_thread_runner, ws, portal)
+            ws_wrapper = WebsocketWrapper(ws, portal)
+            thread_return = anyio.to_thread.run_sync(websocket_thread_runner, ws, portal)  # type: ignore
             await thread_return
     finally:
+        if settings.main.experimental_performance:
+            ws_wrapper.task.cancel()
         try:
             await ws.close()
         except:  # noqa
@@ -229,7 +247,8 @@ async def root(request: Request, fullpath: str = ""):
     if settings.main.root_path is None:
         # use the default root path from the app, which seems to also include the path
         # if we are mounted under a path
-        root_path = request.scope.get("root_path", "")
+        scope = request.scope
+        root_path = scope.get("route_root_path", scope.get("root_path", ""))
         logger.debug("root_path: %s", root_path)
         # or use the script-name header, for instance when running under a reverse proxy
         script_name = request.headers.get("script-name")

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.24.0-py2.py3-none-any.whl", keep_going=True)
+    await micropip.install("/wheels/solara-1.25.1-py2.py3-none-any.whl", keep_going=True)
     import solara
 
     el = solara.Warning("lala")

solara/server/telemetry.py

@@ -20,6 +20,7 @@ from . import settings
 
 logger = logging.getLogger("solara.server.telemetry")
 
+_auto_restart_enabled = False
 _server_user_id_override = None
 _server_start_time = time.time()
 # Privacy note: mixpanel does not store the IP, only the region
@@ -100,7 +101,7 @@ def get_server_user_id():
 
 
 def track(event: str, props: Optional[Dict] = None):
-    if settings.main.mode == "development":
+    if _auto_restart_enabled:
         return
     if not settings.telemetry.mixpanel_enable:
         return
@@ -122,6 +123,7 @@ def track(event: str, props: Optional[Dict] = None):
             "docker": _docker,
             "compute_platform": _compute_platform,
             "vscode": _vscode,
+            "solara_mode": settings.main.mode,
             **(solara_props or {}),
             **(props or {}),
         },
@@ -170,11 +172,14 @@ _thread = threading.Thread(target=_track, daemon=True)
 
 
 def server_start():
-    if settings.main.mode == "development":
+    if _auto_restart_enabled:
         return
     if not settings.telemetry.mixpanel_enable:
         return
-    _thread.start()
+    try:
+        _thread.start()
+    except RuntimeError:
+        pass
 
 
 def server_stop():

solara/server/templates/loader-plain.html

@@ -11,7 +11,7 @@
             </v-card-title>
         </v-card>
     </div>
-    <div v-else style="isolation: isolate">
+    <div v-else>
         <jupyter-widget-mount-point v-if="!loading" mount-id="solara-main">
             A widget with mount-id="solara-main" should go here
         </jupyter-widget-mount-point>

solara/server/templates/loader-solara.html

@@ -28,7 +28,7 @@
             <b>Made with <a href="https://solara.dev">Solara</a></b>
         </div>
     </div>
-    <div v-else style="isolation: isolate">
+    <div v-else>
         <jupyter-widget-mount-point mount-id="solara-main">
             A widget with mount-id="solara-main" should go here
         </jupyter-widget-mount-point>

solara/server/templates/solara.html.j2

@@ -15,31 +15,24 @@
     {{ pre_rendered_css | safe }}
 
     {% if vue3 == True %}
-    <link href="{{cdn}}/@widgetti/solara-vuetify3-app@1.0.0/dist/main.css" rel="stylesheet"></link>
+    <link href="{{cdn}}/@widgetti/solara-vuetify3-app@1.1.0/dist/main.css" rel="stylesheet"></link>
     {% else %}
-    <link href="{{cdn}}/@widgetti/solara-vuetify-app@6.0.0/dist/main.css" rel="stylesheet"></link>
+    <link href="{{cdn}}/@widgetti/solara-vuetify-app@6.1.0/dist/main.css" rel="stylesheet"></link>
     {% endif %}
 
 
     {% if assets.fontawesome_enabled == True %}
     <link rel="stylesheet" href="{{cdn}}{{assets.fontawesome_path}}" type="text/css">
     {% endif %}
-    <link href="{{root_path}}/static/highlight.css" rel="stylesheet">
-    <link href="{{root_path}}/static/highlight-dark.css" rel="stylesheet">
-    </link>
-    <link href="{{root_path}}/static/assets/style.css" rel="stylesheet">
-    </link>
-    <link href="{{root_path}}/static/assets/index.css" rel="stylesheet">
-    </link>
+    {{ resources.include_css("/static/highlight.css") }}
+    {{ resources.include_css("/static/highlight-dark.css") }}
+    {{ resources.include_css("/static/assets/style.css") }}
     {% if theme.variant == "light" %}
-    <link href="{{root_path}}/static/assets/theme-light.css" rel="stylesheet">
-    </link>
+        {{ resources.include_css("/static/assets/theme-light.css") }}
     {% elif theme.variant == "dark" %}
-    <link href="{{root_path}}/static/assets/theme-dark.css" rel="stylesheet">
-    </link>
+        {{ resources.include_css("/static/assets/theme-dark.css") }}
     {% endif %}
-    <link href="{{root_path}}/static/assets/custom.css" rel="stylesheet">
-    </link>
+    {{ resources.include_css("/static/assets/custom.css") }}
 
     <script id="jupyter-config-data" type="application/json">
     {
@@ -64,7 +57,7 @@
         {% endraw -%}
         {# {% include "transition-domino.html" %} #}
         {% include "loader-" ~ theme.loader ~ ".html" %}
-        <v-overlay :value="(connectionStatus != 'connected') & wasConnected">
+        <v-overlay style="z-index: 100002;" :value="(connectionStatus != 'connected') & wasConnected">
             <v-progress-circular indeterminate size="128" style="text-align: center;">Server
                 disconnected.</v-progress-circular>
         </v-overlay>
@@ -201,7 +194,7 @@
 
 <body data-base-url="{{root_path}}/static/">
     {% if perform_check %}
-    <iframe src="https://solara.dev/static/public/success.html?system=solara&check=html" style="display: none"></iframe>
+    <iframe src="https://solara.dev/static/public/success.html?system=solara&check=html&version={{solara_version}}" style="display: none"></iframe>
     {% endif %}
     {% if theme.variant == "auto" %}
     {% endif %}
@@ -216,16 +209,18 @@
     </div>
     {% block after_pre_rendered_html %}{% endblock %}
     {% if vue3 == True %}
+        <link href="{{cdn}}/@widgetti/solara-vuetify3-app@1.1.0/dist/fonts.css" rel="stylesheet"></link>
         {% if production %}
-        <script src="{{cdn}}/@widgetti/solara-vuetify3-app@1.0.0/dist/solara-vuetify-app{{ipywidget_major_version}}.min.js"></script>
+        <script src="{{cdn}}/@widgetti/solara-vuetify3-app@1.1.0/dist/solara-vuetify-app{{ipywidget_major_version}}.min.js"></script>
         {% else %}
-        <script src="{{cdn}}/@widgetti/solara-vuetify3-app@1.0.0/dist/solara-vuetify-app{{ipywidget_major_version}}.js"></script>
+        <script src="{{cdn}}/@widgetti/solara-vuetify3-app@1.1.0/dist/solara-vuetify-app{{ipywidget_major_version}}.js"></script>
         {% endif %}
     {% else %}
+        <link href="{{cdn}}/@widgetti/solara-vuetify-app@6.1.0/dist/fonts.css" rel="stylesheet" fetchpriority="low"></link>
         {% if production %}
-        <script src="{{cdn}}/@widgetti/solara-vuetify-app@6.0.0/dist/solara-vuetify-app{{ipywidget_major_version}}.min.js"></script>
+        <script src="{{cdn}}/@widgetti/solara-vuetify-app@6.1.0/dist/solara-vuetify-app{{ipywidget_major_version}}.min.js"></script>
         {% else %}
-        <script src="{{cdn}}/@widgetti/solara-vuetify-app@6.0.0/dist/solara-vuetify-app{{ipywidget_major_version}}.js"></script>
+        <script src="{{cdn}}/@widgetti/solara-vuetify-app@6.1.0/dist/solara-vuetify-app{{ipywidget_major_version}}.js"></script>
         {% endif %}
     {% endif %}
     {% if production %}
@@ -238,13 +233,13 @@
         console.log("rootPath", solara.rootPath);
     </script>
 
-    <script src="{{root_path}}/static/assets/custom.js"></script>
-    <script src="{{root_path}}/static/assets/theme.js"></script>
+    {{ resources.include_js("/static/assets/custom.js") }}
+    {{ resources.include_js("/static/assets/theme.js") }}
 
     <script src="{{cdn}}/requirejs@2.3.6/require.js" crossorigin="anonymous">
     </script>
-    <script src="{{root_path}}/static/main-vuetify.js"></script>
-    <script src="{{root_path}}/static/ansi.js"></script>
+    {{ resources.include_js("/static/main-vuetify.js") }}
+    {{ resources.include_js("/static/ansi.js") }}
 
     <script>
         solara.production = {{ production | tojson | safe }};

solara/util.py

@@ -1,11 +1,12 @@
 import base64
 import contextlib
+import hashlib
 import os
 import sys
 import threading
 from collections import abc
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, List, Union
+from typing import TYPE_CHECKING, Dict, List, Tuple, Union
 
 if TYPE_CHECKING:
     import numpy as np
@@ -108,7 +109,7 @@ def _flatten_style(style: Union[str, Dict, None] = None) -> str:
     elif isinstance(style, str):
         return style
     elif isinstance(style, dict):
-        return ";".join(f"{k}:{v}" for k, v in style.items())
+        return ";".join(f"{k}:{v}" for k, v in style.items()) + ";"
     else:
         raise ValueError(f"Expected style to be a string or dict, got {type(style)}")
 
@@ -252,3 +253,15 @@ def parse_timedelta(size: str) -> float:
         return float(size[:-1])
     else:
         return float(size)
+
+
+def get_file_hash(path: Path, algorithm="md5") -> Tuple[bytes, str]:
+    """Compute the hash of a file. Note that we also return the file content as bytes."""
+    data = path.read_bytes()
+    if sys.version_info[:2] < (3, 9):
+        # usedforsecurity is only available in Python 3.9+
+        h = hashlib.new(algorithm)
+    else:
+        h = hashlib.new(algorithm, usedforsecurity=False)  # type: ignore
+    h.update(data)
+    return data, h.hexdigest()

solara/website/components/notebook.py

@@ -72,7 +72,7 @@ def execute_notebook(path: Path):
 
 
 @solara.component
-def Notebook(notebook_path: Path, show_last_expressions=False, auto_show_page=False):
+def NotebookExecute(notebook_path: Path, show_last_expressions=False, auto_show_page=False):
     import IPython.core.pylabtools as pylabtools
 
     shell = IPython.get_ipython().kernel.shell
@@ -132,3 +132,46 @@ def Notebook(notebook_path: Path, show_last_expressions=False, auto_show_page=Fa
             else:
                 raise ValueError(f"Unknown cell type: {cell.cell_type}, supported types are: code, markdown")
     return main
+
+
+@solara.component
+def Notebook(notebook_path: Path, show_last_expressions=False, auto_show_page=False, execute=True, outputs={}):
+    if execute:
+        return NotebookExecute(notebook_path, show_last_expressions, auto_show_page)
+    else:
+        with solara.Column(style={"max-width": "100%"}) as main:
+            nb: nbformat.NotebookNode = nbformat.read(notebook_path, 4)
+            for cell_index, cell in enumerate(nb.cells):
+                cell_index += 1
+                if cell.cell_type == "code":
+                    if cell.source.startswith("## solara: skip"):
+                        continue
+                    solara.Markdown(
+                        f"""
+```python
+{cell.source}
+```"""
+                    )
+                    if cell.outputs:
+                        for output in cell.outputs:
+                            if output.output_type == "display_data":
+                                solara.display(output.data, raw=True)
+                            elif output.output_type == "execute_result":
+                                if "text/html" in output.data:
+                                    solara.display(output.data, raw=True)
+                    else:
+                        cell_id = str(cell.id)
+                        output = outputs.get(cell_id) or outputs.get(cell_index)
+                        if output is None:
+                            if cell_id in outputs or cell_index in outputs:
+                                pass  # explicit None
+                            else:
+                                solara.display(f"Output missing for cell: {cell_index} id {cell_id}")
+                        else:
+                            solara.display(output)
+
+                elif cell.cell_type == "markdown":
+                    solara.Markdown(cell.source)
+                else:
+                    raise ValueError(f"Unknown cell type: {cell.cell_type}, supported types are: code, markdown")
+        return main

solara/website/pages/__init__.py

@@ -284,11 +284,13 @@ def Layout(children=[]):
                         with rv.Row(children=children, class_="solara-page-content-search"):
                             pass
 
+            # absolute = True prevents the drawer from being below the overlay it generates
             # Drawer navigation for top menu
             with rv.NavigationDrawer(
                 v_model=show_right_menu,
                 on_v_model=set_show_right_menu,
                 fixed=True,
+                absolute=True,
                 right=True,
                 hide_overlay=False,
                 overlay_color="#000000",
@@ -308,6 +310,7 @@ def Layout(children=[]):
                 v_model=show_left_menu,
                 on_v_model=set_show_left_menu,
                 fixed=True,
+                absolute=True,
                 hide_overlay=False,
                 overlay_color="#000000",
                 overlay_opacity=0.5,

solara/website/pages/api/__init__.py

@@ -118,6 +118,7 @@ items = [
         "name": "Lab (experimental)",
         "icon": "mdi-flask-outline",
         "pages": [
+            "chat",
             "confirmation_dialog",
             "menu",
             "input_date",