solara 1.29.1__py2.py3-none-any.whl → 1.30.1__py2.py3-none-any.whl

solara/server/kernel_context.py

@@ -1,13 +1,22 @@
 import asyncio
+
+try:
+    import contextvars
+except ModuleNotFoundError:
+    contextvars = None  # type: ignore
+
 import dataclasses
 import enum
+import inspect
 import logging
 import os
 import pickle
 import threading
 import time
+import typing
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, cast
+from types import FrameType, ModuleType
+from typing import Any, Callable, Dict, List, NamedTuple, Optional, cast
 
 import ipywidgets as widgets
 import reacton
@@ -36,11 +45,46 @@ class PageStatus(enum.Enum):
     CLOSED = "closed"
 
 
-_on_kernel_start_callbacks: List[Callable[[], Optional[Callable[[], None]]]] = []
+class _on_kernel_callback_entry(NamedTuple):
+    callback: Callable[[], Optional[Callable[[], None]]]
+    callpoint: Optional[Path]
+    module: Optional[ModuleType]
+    cleanup: Callable[[], None]
+
+
+_on_kernel_start_callbacks: List[_on_kernel_callback_entry] = []
+
+
+def _find_root_module_frame() -> Optional[FrameType]:
+    # basically the module where the call stack origined from
+    current_frame = inspect.currentframe()
+    root_module_frame = None
+
+    while current_frame is not None:
+        if current_frame.f_code.co_name == "<module>":
+            root_module_frame = current_frame
+            break
+        current_frame = current_frame.f_back
+
+    return root_module_frame
 
 
-def on_kernel_start(f: Callable[[], Optional[Callable[[], None]]]):
-    _on_kernel_start_callbacks.append(f)
+def on_kernel_start(f: Callable[[], Optional[Callable[[], None]]]) -> Callable[[], None]:
+    root = _find_root_module_frame()
+    path: Optional[Path] = None
+    module: Optional[ModuleType] = None
+    if root is not None:
+        path_str = inspect.getsourcefile(root)
+        module = inspect.getmodule(root)
+        if path_str is not None:
+            path = Path(path_str)
+
+    def cleanup():
+        return _on_kernel_start_callbacks.remove(kce)
+
+    kce = _on_kernel_callback_entry(f, path, module, cleanup)
+    _on_kernel_start_callbacks.append(kce)
+    return cleanup
 
 
 @dataclasses.dataclass
@@ -74,7 +118,7 @@ class VirtualKernelContext:
 
     def __post_init__(self):
         with self:
-            for f in _on_kernel_start_callbacks:
+            for (f, *_) in _on_kernel_start_callbacks:
                 cleanup = f()
                 if cleanup:
                     self.on_close(cleanup)
@@ -106,6 +150,9 @@ 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:
             for f in reversed(self._on_close_callbacks):
@@ -255,12 +302,35 @@ def create_dummy_context():
     return kernel_context
 
 
+if contextvars is not None:
+    if typing.TYPE_CHECKING:
+        async_context_id = contextvars.ContextVar[str]("async_context_id")
+    else:
+        async_context_id = contextvars.ContextVar("async_context_id")
+    async_context_id.set("default")
+else:
+    async_context_id = None
+
+
 def get_current_thread_key() -> str:
-    thread = threading.current_thread()
-    return get_thread_key(thread)
+    if not solara.server.settings.kernel.threaded:
+        if async_context_id is not None:
+            try:
+                key = async_context_id.get()
+            except LookupError:
+                raise RuntimeError("no kernel context set")
+        else:
+            raise RuntimeError("No threading support, and no contextvars support (Python 3.6 is not supported for this)")
+    else:
+        thread = threading.current_thread()
+        key = get_thread_key(thread)
+    return key
 
 
 def get_thread_key(thread: threading.Thread) -> str:
+    if not solara.server.settings.kernel.threaded:
+        if async_context_id is not None:
+            return async_context_id.get()
     thread_key = thread._name + str(thread._ident)  # type: ignore
     return thread_key
 
@@ -318,6 +388,7 @@ def initialize_virtual_kernel(session_id: str, kernel_id: str, websocket: websoc
             widgets.register_comm_target(kernel)
             appmodule.register_solara_comm_target(kernel)
     with context:
+        assert has_current_context()
         assert kernel is Kernel.instance()
         kernel.shell_stream = WebsocketStreamWrapper(websocket, "shell")
         kernel.control_stream = WebsocketStreamWrapper(websocket, "control")

solara/server/patch.py

@@ -295,7 +295,10 @@ def _WidgetContextAwareThread__bootstrap(self):
         # we need to call this manually, because set_context_for_thread
         # uses this, and the original _bootstrap calls it too late for us
         self._set_ident()
+        if kernel_context.async_context_id is not None:
+            kernel_context.async_context_id.set(self.current_context.id)
         kernel_context.set_context_for_thread(self.current_context, self)
+
         shell = self.current_context.kernel.shell
         shell.display_pub.register_hook(shell.display_in_reacton_hook)
     try:

solara/server/reload.py

@@ -152,13 +152,13 @@ class Reloader:
             self._first = False
 
     def _on_change(self, name):
-        # used for testing
-        self.reload_event_next.set()
         # flag that we need to reload all modules next time
         self.requires_reload = True
         # and forward callback
         if self.on_change:
             self.on_change(name)
+        # used for testing
+        self.reload_event_next.set()
 
     def close(self):
         self.watcher.close()

solara/server/server.py

@@ -13,7 +13,6 @@ import ipyvue
 import ipywidgets
 import jinja2
 import requests
-
 import solara
 import solara.routing
 import solara.settings
@@ -35,6 +34,7 @@ ipykernel_major = int(ipykernel.__version__.split(".")[0])
 ipywidgets_major = int(ipywidgets.__version__.split(".")[0])
 cache_memory = solara.cache.Memory(max_items=128)
 vue3 = ipyvue.__version__.startswith("3")
+_redirects: Dict[str, str] = {}
 
 # first look at the project directory, then the builtin solara directory
 
@@ -302,9 +302,9 @@ def read_root(path: str, root_path: str = "", render_kwargs={}, use_nbextensions
             code = content_utf8
         elif embed:
             content_utf8 = content.decode("utf-8")
-            code = f"<style>/*\npath={path}\n*/\n{content_utf8}</style>"
+            code = f'<style class="solara-template-css">/*\npath={path}\n*/\n{content_utf8}</style>'
         else:
-            code = f'<link rel="stylesheet" type="text/css" href="{url}">'
+            code = f'<link rel="stylesheet" type="text/css" href="{url}" class="solara-template-css">'
         return Markup(code)
 
     def include_js(path: str, module=False) -> Markup:

solara/server/settings.py

@@ -86,6 +86,7 @@ class Assets(BaseSettings):
 class Kernel(BaseSettings):
     cull_timeout: str = "24h"
     max_count: Optional[int] = None
+    threaded: bool = solara.util.has_threads
 
     class Config:
         env_prefix = "solara_kernel_"

solara/server/starlette.py

@@ -6,7 +6,7 @@ import os
 import sys
 import threading
 import typing
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, Dict, List, Optional, Set, Union, cast
 from uuid import uuid4
 
 import anyio
@@ -40,7 +40,7 @@ from starlette.middleware import Middleware
 from starlette.middleware.authentication import AuthenticationMiddleware
 from starlette.middleware.gzip import GZipMiddleware
 from starlette.requests import HTTPConnection, Request
-from starlette.responses import HTMLResponse, JSONResponse, Response
+from starlette.responses import HTMLResponse, JSONResponse, RedirectResponse, Response
 from starlette.routing import Mount, Route, WebSocketRoute
 from starlette.staticfiles import StaticFiles
 from starlette.types import Receive, Scope, Send
@@ -96,10 +96,14 @@ class WebsocketDebugInfo:
 class WebsocketWrapper(websocket.WebsocketWrapper):
     ws: starlette.websockets.WebSocket
 
-    def __init__(self, ws: starlette.websockets.WebSocket, portal: anyio.from_thread.BlockingPortal) -> None:
+    def __init__(self, ws: starlette.websockets.WebSocket, portal: Optional[anyio.from_thread.BlockingPortal]) -> None:
         self.ws = ws
         self.portal = portal
         self.to_send: List[Union[str, bytes]] = []
+        # following https://docs.python.org/3/library/asyncio-task.html#asyncio.create_task
+        # we store a strong reference
+        self.tasks: Set[asyncio.Task] = set()
+        self.event_loop = asyncio.get_event_loop()
         if settings.main.experimental_performance:
             self.task = asyncio.ensure_future(self.process_messages_task())
 
@@ -114,28 +118,44 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
                     await self.ws.send_text(first)
 
     def close(self):
-        self.portal.call(self.ws.close)  # type: ignore
+        if self.portal is None:
+            asyncio.ensure_future(self.ws.close())
+        else:
+            self.portal.call(self.ws.close)  # type: ignore
 
     def send_text(self, data: str) -> None:
-        if settings.main.experimental_performance:
-            self.to_send.append(data)
+        if self.portal is None:
+            task = self.event_loop.create_task(self.ws.send_text(data))
+            self.tasks.add(task)
+            task.add_done_callback(self.tasks.discard)
         else:
-            self.portal.call(self.ws.send_bytes, data)  # type: ignore
+            if settings.main.experimental_performance:
+                self.to_send.append(data)
+            else:
+                self.portal.call(self.ws.send_bytes, data)  # type: ignore
 
     def send_bytes(self, data: bytes) -> None:
-        if settings.main.experimental_performance:
-            self.to_send.append(data)
+        if self.portal is None:
+            task = self.event_loop.create_task(self.ws.send_bytes(data))
+            self.tasks.add(task)
+            task.add_done_callback(self.tasks.discard)
         else:
-            self.portal.call(self.ws.send_bytes, data)  # type: ignore
+            if settings.main.experimental_performance:
+                self.to_send.append(data)
+            else:
+                self.portal.call(self.ws.send_bytes, data)  # type: ignore
 
     async def receive(self):
-        if hasattr(self.portal, "start_task_soon"):
-            # version 3+
-            fut = self.portal.start_task_soon(self.ws.receive)  # type: ignore
+        if self.portal is None:
+            message = await asyncio.ensure_future(self.ws.receive())
         else:
-            fut = self.portal.spawn_task(self.ws.receive)  # type: ignore
+            if hasattr(self.portal, "start_task_soon"):
+                # version 3+
+                fut = self.portal.start_task_soon(self.ws.receive)  # type: ignore
+            else:
+                fut = self.portal.spawn_task(self.ws.receive)  # type: ignore
 
-        message = await asyncio.wrap_future(fut)
+            message = await asyncio.wrap_future(fut)
         if "text" in message:
             return message["text"]
         elif "bytes" in message:
@@ -237,35 +257,45 @@ async def _kernel_connection(ws: starlette.websockets.WebSocket):
         WebsocketDebugInfo.connecting -= 1
         WebsocketDebugInfo.open += 1
 
-    def websocket_thread_runner(ws: starlette.websockets.WebSocket, portal: anyio.from_thread.BlockingPortal):
-        async def run():
+    async def run(ws_wrapper: WebsocketWrapper):
+        if kernel_context.async_context_id is not None:
+            kernel_context.async_context_id.set(uuid4().hex)
+        assert session_id is not None
+        assert kernel_id is not None
+        telemetry.connection_open(session_id)
+        headers_dict: Dict[str, List[str]] = {}
+        for k, v in ws.headers.items():
+            if k not in headers_dict.keys():
+                headers_dict[k] = [v]
+            else:
+                headers_dict[k].append(v)
+        await server.app_loop(ws_wrapper, ws.cookies, headers_dict, session_id, kernel_id, page_id, user)
+
+    def websocket_thread_runner(ws_wrapper: WebsocketWrapper, portal: anyio.from_thread.BlockingPortal):
+        async def run_wrapper():
             try:
-                assert session_id is not None
-                assert kernel_id is not None
-                telemetry.connection_open(session_id)
-                headers_dict: Dict[str, List[str]] = {}
-                for k, v in ws.headers.items():
-                    if k not in headers_dict.keys():
-                        headers_dict[k] = [v]
-                    else:
-                        headers_dict[k].append(v)
-                await server.app_loop(ws_wrapper, ws.cookies, headers_dict, session_id, kernel_id, page_id, user)
+                await run(ws_wrapper)
             except:  # noqa
-                await portal.stop(cancel_remaining=True)
+                if portal is not None:
+                    await portal.stop(cancel_remaining=True)
                 raise
             finally:
                 telemetry.connection_close(session_id)
 
         # sometimes throws: RuntimeError: Already running asyncio in this thread
-        anyio.run(run)  # type: ignore
+        anyio.run(run_wrapper)  # 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:
-            ws_wrapper = WebsocketWrapper(ws, portal)
-            thread_return = anyio.to_thread.run_sync(websocket_thread_runner, ws, portal, limiter=limiter)  # type: ignore
-            await thread_return
+        if settings.kernel.threaded:
+            async with anyio.from_thread.BlockingPortal() as portal:
+                ws_wrapper = WebsocketWrapper(ws, portal)
+                thread_return = anyio.to_thread.run_sync(websocket_thread_runner, ws_wrapper, portal, limiter=limiter)  # type: ignore
+                await thread_return
+        else:
+            ws_wrapper = WebsocketWrapper(ws, None)
+            await run(ws_wrapper)
     finally:
         if settings.main.experimental_performance:
             try:
@@ -315,6 +345,9 @@ async def root(request: Request, fullpath: str = ""):
     request_path = request.url.path
     if request_path.startswith(root_path):
         request_path = request_path[len(root_path) :]
+    if request_path in server._redirects.keys():
+        return RedirectResponse(server._redirects[request_path])
+
     content = server.read_root(request_path, root_path)
     if content is None:
         if settings.oauth.private and not request.user.is_authenticated:

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

solara/server/templates/solara.html.j2

@@ -11,13 +11,11 @@
 
     {% block header %}
 
-
     {{ pre_rendered_css | safe }}
-
     {% if vue3 == True %}
-    <link href="{{cdn}}/@widgetti/solara-vuetify3-app@5.0.1/dist/main{{ipywidget_major_version}}.css" rel="stylesheet"></link>
+    <link href="{{cdn}}/@widgetti/solara-vuetify3-app@5.0.1/dist/main{{ipywidget_major_version}}.css" rel="stylesheet" class="solara-template-css"></link>
     {% else %}
-    <link href="{{cdn}}/@widgetti/solara-vuetify-app@10.0.1/dist/main{{ipywidget_major_version}}.css" rel="stylesheet"></link>
+    <link href="{{cdn}}/@widgetti/solara-vuetify-app@10.0.1/dist/main{{ipywidget_major_version}}.css" rel="stylesheet" class="solara-template-css"></link>
     {% endif %}
 
 
@@ -27,8 +25,7 @@
     {{ resources.include_css("/static/highlight.css") }}
     {{ resources.include_css("/static/highlight-dark.css") }}
     {{ resources.include_css("/static/assets/style.css") }}
-    <style id="jupyter-theme-css">
-        {{ resources.include_css("/static/assets/theme-"~theme.variant~".css") }}
+    <style id="jupyter-theme-css" class="solara-template-css">
     </style>
     {{ resources.include_css("/static/assets/custom.css") }}
 
@@ -38,9 +35,24 @@
         "kernelId": "1234"
     }
     </script>
-    <style>
+    <style class="solara-template-css">
         {% include "loader-"~theme.loader~".css" %}
     </style>
+    <!-- Include Vuetify background colours so static html from SSG renders the right general colour theme
+        before first render. We remove these after Vue takes over rendering to avoid collisions -->
+    <style id="pre-render-theme">
+    .theme--light .v-sheet {
+        background-color: #fff;
+        border-color: #fff;
+        color: rgba(0,0,0,.87)
+    }
+
+    .theme--dark .v-sheet {
+        background-color: #1e1e1e;
+        border-color: #1e1e1e;
+        color: #fff
+    }
+</style>
     {% endblock header %}
 </head>
 {% raw -%}
@@ -175,6 +187,38 @@
         {# next div is used in ssg code to see if vue took over rendering #}
         <div id="pre-rendered-html-present" style="display: none"></div>
     </div>
+    <script>
+        var theme = {{ theme | tojson | safe }}
+        function getThemeVariant() {
+            if (localStorage.getItem(':solara:theme.variant')) {
+                return JSON.parse(localStorage.getItem(':solara:theme.variant'))
+            }
+            return theme.variant;
+        }
+        if (localStorage.getItem(':solara:theme.variant')) {
+            theme.variant = JSON.parse(localStorage.getItem(':solara:theme.variant'))
+        }
+        function prefersDarkScheme() {
+            return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches
+        }
+        function inDarkMode() {
+            if (getThemeVariant() == 'auto') {
+                return prefersDarkScheme();
+            }
+            else {
+                return getThemeVariant() == 'dark';
+            }
+        }
+        // Init theme
+        let appContainer = document.getElementById('app');
+        if (inDarkMode()) {
+            appContainer.classList.remove('theme--light');
+            appContainer.classList.add('theme--dark');
+        } else {
+            appContainer.classList.remove('theme--dark');
+            appContainer.classList.add('theme--light');
+        }
+    </script>
     {% block after_pre_rendered_html %}{% endblock %}
     {% if vue3 == True %}
         <link href="{{cdn}}/@widgetti/solara-vuetify3-app@5.0.1/dist/fonts.css" rel="stylesheet"></link>
@@ -194,6 +238,12 @@
     <script>
         solara.rootPath = {{ root_path | tojson | safe}};
         console.log("rootPath", solara.rootPath);
+
+        async function changeThemeCSS(theme) {
+            let css = await fetch(`${solara.rootPath}/static/assets/theme-${theme}.css`).then(r => r.text());
+            document.getElementById('jupyter-theme-css').innerHTML = css;
+        }
+        changeThemeCSS(inDarkMode() ? 'dark' : 'light');
     </script>
 
     {{ resources.include_js("/static/assets/custom.js") }}
@@ -208,27 +258,6 @@
         solara.production = {{ production | tojson | safe }};
         const themeVariants = ['light', 'dark', 'auto']
         solara.preRendered = {{ pre_rendered_html | safe | length | tojson }} > 0
-        var theme = {{ theme | tojson | safe }}
-        function getThemeVariant() {
-            if (localStorage.getItem(':solara:theme.variant')) {
-                return JSON.parse(localStorage.getItem(':solara:theme.variant'))
-            }
-            return theme.variant;
-        }
-        if (localStorage.getItem(':solara:theme.variant')) {
-            theme.variant = JSON.parse(localStorage.getItem(':solara:theme.variant'))
-        }
-        function prefersDarkScheme() {
-            return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches
-        }
-        function inDarkMode() {
-            if (getThemeVariant() == 'auto') {
-                return prefersDarkScheme();
-            }
-            else {
-                return getThemeVariant() == 'dark';
-            }
-        }
     </script>
 
     <script>
@@ -256,11 +285,7 @@
                 window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', event => {
                     this.$vuetify.theme.dark = inDarkMode();
                 });
-                if (this.$vuetify.theme.dark) {
-                    this.changeThemeCSS('dark');
-                } else {
-                    this.changeThemeCSS('light');
-                }
+                document.getElementById('pre-render-theme').remove();
             },
             methods: {
                 stateReset() {
@@ -275,10 +300,6 @@
                 reload() {
                     location.reload();
                 },
-                async changeThemeCSS(theme) {
-                    let css = await fetch(`/static/assets/theme-${theme}.css`).then(r => r.text());
-                    document.getElementById('jupyter-theme-css').innerHTML = css;
-                }
             },
             watch: {
                 kernelBusy: function (value) {
@@ -325,15 +346,14 @@
                     }
                 },
                 '$vuetify.theme.dark': function (value) {
-                    let app = document.getElementById('app');
                     if ( value ) {
                         this.changeThemeCSS('dark');
-                        app.classList.remove('theme--light');
-                        app.classList.add('theme--dark');
+                        appContainer.classList.remove('theme--light');
+                        appContainer.classList.add('theme--dark');
                     } else {
                         this.changeThemeCSS('light');
-                        app.classList.remove('theme--dark');
-                        app.classList.add('theme--light');
+                        appContainer.classList.remove('theme--dark');
+                        appContainer.classList.add('theme--light');
                     }
                 }
             },

solara/tasks.py

@@ -32,12 +32,7 @@ P = typing_extensions.ParamSpec("P")
 
 logger = logging.getLogger("solara.task")
 
-try:
-    threading.Thread(target=lambda: None).start()
-    has_threads = True
-except RuntimeError:
-    has_threads = False
-has_threads
+has_threads = solara.util.has_threads
 
 
 class TaskState(Enum):

solara/util.py

@@ -1,12 +1,15 @@
 import base64
 import contextlib
+import gzip
 import hashlib
+import json
 import os
 import sys
 import threading
 from collections import abc
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, List, Tuple, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+from urllib.parse import urlencode
 
 if TYPE_CHECKING:
     import numpy as np
@@ -21,6 +24,12 @@ SOLARA_ALLOW_OTHER_TRACER = os.environ.get("SOLARA_ALLOW_OTHER_TRACER", False) i
 ipyvuetify_major_version = int(ipyvuetify.__version__.split(".")[0])
 ipywidgets_major = int(ipywidgets.__version__.split(".")[0])
 
+try:
+    threading.Thread(target=lambda: None).start()
+    has_threads = True
+except RuntimeError:
+    has_threads = False
+
 
 def github_url(file):
     rel_path = os.path.relpath(file, Path(solara.__file__).parent.parent)
@@ -28,6 +37,19 @@ def github_url(file):
     return github_url
 
 
+def pycafe_url(*, path: Path, requirements: Optional[List[str]] = None):
+    json_object = {"code": path.read_text("utf8")}
+    if requirements:
+        json_object["requirements"] = "\n".join(requirements)
+    json_text = json.dumps(json_object)
+    # gzip -> base64
+    compressed_json_text = gzip.compress(json_text.encode("utf8"))
+    base64_text = base64.b64encode(compressed_json_text).decode("utf8")
+    query = urlencode({"c": base64_text})
+    base_url = "https://app.py.cafe"
+    return f"{base_url}/snippet/solara?{query}"
+
+
 def github_edit_url(file):
     # e.g. https://github.com/widgetti/solara/edit/master/solara/__init__.py
     rel_path = os.path.relpath(file, Path(solara.__file__).parent.parent)