solara 1.29.0__py2.py3-none-any.whl → 1.30.0__py2.py3-none-any.whl

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.0-py2.py3-none-any.whl", keep_going=True)
+    await micropip.install("/wheels/solara-1.30.0-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)

solara/website/assets/custom.css

@@ -27,6 +27,11 @@
     --dark-color-text: hsla(0,0%,100%,.7);
     --dark-color-grey: #ababab;
     --dark-color-grey-light: #202020;
+
+    --docs-color-grey: #40362E;
+    --docs-social-discord: #5865F2;
+    --docs-social-github: #333;
+    --docs-social-twitter: #000000;
 }
 
 html,
@@ -178,6 +183,56 @@ blockquote p:last-child {
     background-color: var(--dark-color-primary-lightest);
 }
 
+/* API PAGE REFACTOR STYLE */
+
+.v-sheet.api-search-container{
+    flex-grow: 1;
+}
+    .v-sheet.api-search-container .v-input{
+        flex-grow: 0;
+    }
+.v-sheet.docs-card-container{
+    width: 100%;
+    padding: 0 10%;
+    justify-content: start;
+    align-content: center;
+    flex-wrap: wrap !important;
+    flex-grow: 1;
+    row-gap: 20px;
+}
+.v-sheet.docs-card-container > a{
+    height: fit-content;
+}
+.v-sheet.docs-card-container > a > .docs-card{
+    display: flex;
+    width: 20rem;
+    height: 12rem;
+    border-radius: 16px !important;
+    color: var(--color-grey-light);
+}
+    .v-sheet.docs-card-container > a .docs-card-icon{
+        padding-right: 1.5rem;
+        transition: ease padding 0.25s;
+    }
+    .v-sheet.docs-card-container > a:hover .docs-card-icon{
+        color: var(--color-primary);
+        padding-right: 0.5rem;
+        transition: ease padding 0.25s;
+    }
+.component-card{
+    display: flex;
+    flex-direction: column;
+    width: 19rem;
+}
+.social-logo-container{
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    width: 4rem;
+    height: 4rem;
+    border-radius: 8px;
+}
+
 /* vuetify component overrides */
 
 .v-btn.solara-docs-button {
@@ -354,6 +409,7 @@ blockquote p:last-child {
 }
 
 .solara-autorouter-content {
+    padding-top: 2rem;
     max-width: 100%;
 }
 

solara/website/components/__init__.py

@@ -1,3 +1,4 @@
+from .docs import CategoryLayout, Gallery, NoPage, SubCategoryLayout, WithCode  # noqa
 from .header import Header
 from .hero import Hero
 

solara/website/components/algolia_api.vue

@@ -0,0 +1,157 @@
+<template>
+    <v-menu
+        v-model="show_results"
+        offset-y>
+        <template v-slot:activator="{ on }">
+                <v-text-field
+                    v-model="query"
+                    prepend-inner-icon="mdi-magnify"
+                    hide-details
+                    :placeholder="mac ? '⌘K to search' : 'Ctrl+K to search'"
+                    outlined
+                    rounded
+                    clearable
+                    ref="search"
+                    style="max-width: 50%; flex-grow: 1;"
+                    @click="show($event, on);"
+                    @keyup.enter="item = 0"
+                ></v-text-field>
+        </template>
+        <v-list v-if="results != null && results.length == 0">
+            <v-list-item>
+                <v-list-item-content>
+                    {{this.query == "" ? "Start Typing to Search" : "No search results found."}}
+                </v-list-item-content>
+            </v-list-item>
+        </v-list>
+        <v-list v-else>
+            <v-list-item-group v-model="item">
+                <v-list-item v-for="(element, index) in this.results.hits" :key="element['url']">
+                    <v-list-item-content>
+                        <v-list-item-title>{{ element.hierarchy[element.type] }}</v-list-item-title>
+                    </v-list-item-content>
+                </v-list-item>
+            </v-list-item-group>
+            <v-list-item>
+                <v-list-item-content>
+                    <v-list-item-title>And {{ this.results.nbHits - 10}} More...</v-list-item-title>
+                </v-list-item-content>
+            </v-list-item>
+        </v-list>
+    </v-menu>
+</template>
+<script>
+const search = ref(null);
+module.exports = {
+    async mounted() {
+        window.search = this;
+        await this.loadRequire();
+        this.algoliasearch = (await this.import([`https://cdn.jsdelivr.net/npm/algoliasearch@4.20.0/dist/algoliasearch-lite.umd.js`]))[0];
+        this.initSearch();
+        window.search = this;
+    },
+    watch: {
+        query ( value ) {
+            this.show_results = true;
+            this.search();
+        },
+        item ( value ) {
+            if ( this.results.hits != null && this.results.hits.length > 0 ) {
+                let url = this.results.hits[value].url;
+                if (url.startsWith("https://solara.dev")) {
+                    url = url.slice(18);
+                }
+                solara.router.push( url );
+            }
+        },
+    },
+    methods: {
+        show( e, on ) {
+            this.show_results = false;
+            this.$nextTick( () => {
+                on.click( e )
+            } );
+        },
+        initSearch() {
+            this.client = this.algoliasearch( '9KW9L7O5EQ', '647ca12ba642437cc40c2adee4a78d08' );
+            this.index = this.client.initIndex( 'solara' );
+            this.mac = window.navigator.userAgent.indexOf("Mac") != -1;
+            document.addEventListener( 'keydown', ( e ) => {
+
+                if (this.mac) {
+                    if ( this.$refs.search && e.metaKey && e.key === 'k' ) {
+                        this.$refs.search.focus();
+                    }
+                }else{
+                    if ( this.$refs.search && e.ctrlKey && e.key === 'k' ) {
+                        this.$refs.search.focus();
+                    }
+                }
+            });
+        },
+        async search() {
+            results = await this.index.search( this.query, { hitsPerPage: 10 } );
+            if (results) {
+                this.results = results;
+            }else{
+                this.$set(this.results, []);
+            }
+        },
+        import(dependencies) {
+            return this.loadRequire().then(
+                () => {
+                    if (window.jupyterVue) {
+                        // in jupyterlab, we take Vue from ipyvue/jupyterVue
+                        define("vue", [], () => window.jupyterVue.Vue);
+                    } else {
+                        define("vue", ['jupyter-vue'], jupyterVue => jupyterVue.Vue);
+                    }
+                    return new Promise((resolve, reject) => {
+                        requirejs(dependencies, (...modules) => resolve(modules));
+                    })
+                }
+            );
+        },
+        loadRequire() {
+            return new Promise((resolve, reject) => {
+                const script = document.createElement('script');
+                script.src = `${this.getCdn()}/requirejs@2.3.6/require.js`;
+                script.onload = resolve;
+                script.onerror = reject;
+                document.head.appendChild(script);
+            });
+        },
+        getBaseUrl() {
+            if (window.solara && window.solara.rootPath !== undefined) {
+                return solara.rootPath + "/";
+            }
+            // if base url is set, we use ./ for relative paths compared to the base url
+            if (document.getElementsByTagName("base").length) {
+                return document.baseURI;
+            }
+            const labConfigData = document.getElementById('jupyter-config-data');
+            if (labConfigData) {
+                /* lab and Voila */
+                return JSON.parse(labConfigData.textContent).baseUrl;
+            }
+            let base = document.body.dataset.baseUrl || document.baseURI;
+            if (!base.endsWith('/')) {
+                base += '/';
+            }
+            return base
+        },
+        getCdn() {
+            return (typeof solara_cdn !== "undefined" && solara_cdn) || `${this.getBaseUrl()}_solara/cdn`;
+        },
+    },
+    data(){
+        return {
+            query: '',
+            results: [],
+            item: null,
+            show_results: false,
+            mac: false,
+        }
+    },
+}
+</script>