solara-ui 1.39.0__py2.py3-none-any.whl → 1.40.0__py2.py3-none-any.whl

solara/__init__.py

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

solara/components/__init__.py

@@ -33,6 +33,7 @@ from .togglebuttons import (  # noqa: F401 F403
     ToggleButtonsSingle,
 )
 from .input import InputText, InputFloat, InputInt  # noqa: F401 F403
+from .input_text_area import InputTextArea  # noqa: F401 F403
 from .pivot_table import PivotTableView, PivotTable, PivotTableCard  # noqa: F401 F403
 from .head import Head  # noqa: F401 F403
 from .title import Title  # noqa: F401 F403

solara/components/input_text_area.py

@@ -0,0 +1,86 @@
+from typing import Callable, Optional, Union, List
+from .input import use_change
+import solara
+from solara.alias import rv as v
+
+
+@solara.component
+def InputTextArea(
+    label: str,
+    value: Union[str, solara.Reactive[str]] = "",
+    on_value: Callable[[str], None] = None,
+    disabled: bool = False,
+    continuous_update: bool = False,
+    update_events: List[str] = ["focusout"],
+    error: Union[bool, str] = False,
+    message: Optional[str] = None,
+    auto_grow: bool = True,
+    rows: int = 5,
+):
+    r"""Free form text area input.
+
+    ### Basic example:
+
+    ```solara
+    import solara
+
+    text = solara.reactive("Hello\nWorld\n!!!")
+    continuous_update = solara.reactive(True)
+
+    @solara.component
+    def Page():
+        solara.Checkbox(label="Continuous update", value=continuous_update)
+        solara.InputTextArea("Enter some text", value=text, continuous_update=continuous_update.value)
+        with solara.Row():
+            solara.Button("Clear", on_click=lambda: text.set(""))
+            solara.Button("Reset", on_click=lambda: text.set("Hello\nWorld\n!!!"))
+        solara.Markdown(f"**You entered**: {text.value}")
+    ```
+
+
+    ## Arguments
+
+    * `label`: Label to display next to the slider.
+    * `value`: The currently entered value.
+    * `on_value`: Callback to call when the value changes.
+    * `disabled`: Whether the input is disabled.
+    * `continuous_update`: Whether to call the `on_value` callback on every change or only when the input loses focus or the enter key is pressed.
+    * `update_events`: A list of events that should trigger `on_value`. If continuous update is enabled, this will effectively be ignored,
+        since updates will happen every change.
+    * `auto_grow`: Whether the text area auto grows with more text.
+    * `rows`: Number of empty rows to display.
+    * `error`: If truthy, show the input as having an error (in red). If a string is passed, it will be shown as the error message.
+    * `message`: Message to show below the input. If `error` is a string, this will be ignored.
+    * `classes`: List of CSS classes to apply to the input.
+    * `style`: CSS style to apply to the input.
+    """
+    reactive_value = solara.use_reactive(value, on_value)
+    del value, on_value
+
+    def set_value_cast(value):
+        reactive_value.value = str(value)
+
+    def on_v_model(value):
+        if continuous_update:
+            set_value_cast(value)
+
+    messages = []
+    if error and isinstance(error, str):
+        messages.append(error)
+    elif message:
+        messages.append(message)
+    text_area = v.Textarea(
+        v_model=reactive_value.value,
+        on_v_model=on_v_model,
+        label=label,
+        disabled=disabled,
+        error=bool(error),
+        messages=messages,
+        solo=True,
+        hide_details=True,
+        outlined=True,
+        rows=rows,
+        auto_grow=auto_grow,
+    )
+    use_change(text_area, set_value_cast, enabled=not continuous_update, update_events=update_events)
+    return text_area

solara/components/markdown.py

@@ -128,7 +128,7 @@ module.exports = {
                 href = location.pathname + href.substr(1);
                 a.attributes['href'].href = href;
             }
-            let authLink = href.starswith("/_solara/auth/");
+            let authLink = href.startsWith("/_solara/auth/");
             if( (href.startsWith("./") || href.startsWith("/")) && !authLink) {
                 a.onclick = e => {
                     console.log("clicked", href)

solara/hooks/use_thread.py

@@ -15,7 +15,7 @@ logger = logging.getLogger("solara.hooks.use_thread")
 
 
 def use_thread(
-    callback=Union[
+    callback: Union[
         Callable[[threading.Event], T],
         Iterator[Callable[[threading.Event], T]],
         Callable[[], T],
@@ -69,11 +69,11 @@ def use_thread(
             # result.current = None
             set_result_state(ResultState.RUNNING)
 
-            sig = inspect.signature(callback)
+            sig = inspect.signature(callback)  # type: ignore
             if sig.parameters:
-                f = functools.partial(callback, cancel)
+                f = functools.partial(callback, cancel)  # type: ignore
             else:
-                f = callback
+                f = callback  # type: ignore
             try:
                 try:
                     # we only use the cancel_guard context manager around

solara/lab/components/chat.py

@@ -46,7 +46,9 @@ def ChatInput(
     send_callback: Optional[Callable] = None,
     disabled: bool = False,
     style: Optional[Union[str, Dict[str, str]]] = None,
+    input_text_style: Optional[Union[str, Dict[str, str]]] = None,
     classes: List[str] = [],
+    input_text_classes: List[str] = [],
 ):
     """
     The ChatInput component renders a text input together with a send button.
@@ -56,11 +58,14 @@ def ChatInput(
     * `send_callback`: A callback function for when the user presses enter or clicks the send button.
     * `disabled`: Whether the input should be disabled. Useful for disabling sending further messages while a chatbot is replying,
         among other things.
-    * `style`: CSS styles to apply to the component. Either a string or a dictionary. These styles are applied to the container component.
+    * `style`: CSS styles to apply to the `solara.Row` containing the input field and submit button. Either a string or a dictionary.
+    * `input_text_style`: CSS styles to apply to the `InputText` part of the component. Either a string or a dictionary.
     * `classes`: A list of CSS classes to apply to the component. Also applied to the container.
+    * `input_text_classes`: A list of CSS classes to apply to the `InputText` part of the component.
     """
     message, set_message = solara.use_state("")  # type: ignore
     style_flat = solara.util._flatten_style(style)
+    input_text_style_flat = solara.util._flatten_style(input_text_style)
 
     if "align-items" not in style_flat:
         style_flat += " align-items: center;"
@@ -79,8 +84,9 @@ def ChatInput(
             rounded=True,
             filled=True,
             hide_details=True,
-            style_="flex-grow: 1;",
+            style_="flex-grow: 1;" + input_text_style_flat,
             disabled=disabled,
+            class_=" ".join(input_text_classes),
         )
 
         use_change(message_input, send, update_events=["keyup.enter"])

solara/server/assets/style.css

@@ -75,7 +75,8 @@ div.solara-markdown-output {
 
 
 div.highlight {
-    background-color: #eee;
+    border: 1px solid var(--color-border-appbar);
+    background-color: #fafafa;
     padding: 30px;
     border-radius: 20px;
     margin-top: 15px;

solara/server/flask.py

@@ -192,7 +192,7 @@ def assets(path):
     return flask.Response("not found", status=404)
 
 
-@blueprint.route("/static/nbextensions/<dir>/<filename>")
+@blueprint.route("/jupyter/nbextensions/<dir>/<filename>")
 def nbext(dir, filename):
     if not allowed():
         abort(401)

solara/server/jupyter/server_extension.py

@@ -2,6 +2,7 @@ from jupyter_server.utils import url_path_join
 
 from solara.server.cdn_helper import cdn_url_path
 from solara.server.jupyter.cdn_handler import CdnHandler
+from .solara import SolaraHandler, Assets, ReadyZ
 
 
 def _jupyter_server_extension_paths():
@@ -9,6 +10,11 @@ def _jupyter_server_extension_paths():
 
 
 def _load_jupyter_server_extension(server_app):
+    # a dummy app, so that server.read_root can be used
+    import solara.server.app
+
+    solara.server.app.apps["__default__"] = solara.server.app.AppScript("solara.server.jupyter.solara:Page")
+
     web_app = server_app.web_app
 
     host_pattern = ".*$"
@@ -17,7 +23,11 @@ def _load_jupyter_server_extension(server_app):
     web_app.add_handlers(
         host_pattern,
         [
-            (url_path_join(base_url, f"/{cdn_url_path}/(.*)"), CdnHandler, {}),
+            (url_path_join(base_url, f"/{cdn_url_path}/(.*)"), CdnHandler, {}),  # kept for backward compatibility
+            (url_path_join(base_url, f"/solara/{cdn_url_path}/(.*)"), CdnHandler, {}),
+            (url_path_join(base_url, "/solara/static/assets/(.*)"), Assets, {}),
+            (url_path_join(base_url, "/solara/readyz"), ReadyZ, {}),
+            (url_path_join(base_url, "/solara(.*)"), SolaraHandler, {}),
         ],
     )
 

solara/server/jupyter/solara.py

@@ -0,0 +1,91 @@
+import json
+import logging
+import os
+from pathlib import Path
+
+import tornado.web
+from jupyter_server.base.handlers import JupyterHandler
+import solara.server.server as server
+
+from solara.server.utils import path_is_child_of
+import solara
+
+logger = logging.getLogger("solara.server.jupyter.solara")
+
+
+@solara.component
+def Page():
+    solara.Error("Hi, you should not see this, we only support ipypopout for now")
+
+
+class SolaraHandler(JupyterHandler):
+    async def get(self, path=None):
+        try:
+            # base url ends with /
+            base_url = self.settings["base_url"]
+            # root_path's do not end with /
+            jupyter_root_path = ""
+            if base_url and base_url.endswith("/"):
+                jupyter_root_path = base_url[:-1]
+            root_path = f"{jupyter_root_path}/solara"
+            content = server.read_root(path="", root_path=root_path, jupyter_root_path=jupyter_root_path)
+        except Exception as e:
+            logger.exception(e)
+            raise tornado.web.HTTPError(500)
+
+        if content is None:
+            raise tornado.web.HTTPError(404)
+
+        self.set_header("Content-Type", "text/html")
+        self.write(content)
+
+
+# similar to voila
+class MultiStaticFileHandler(tornado.web.StaticFileHandler):
+    """A static file handler that 'merges' a list of directories
+
+    If initialized like this::
+
+        application = web.Application([
+            (r"/content/(.*)", web.MultiStaticFileHandler, {"paths": ["/var/1", "/var/2"]}),
+        ])
+
+    A file will be looked up in /var/1 first, then in /var/2.
+
+    """
+
+    def initialize(self, paths, default_filename=None):  # type: ignore
+        self.roots = paths
+        super().initialize(path=paths[0], default_filename=default_filename)
+
+    def get_absolute_path(self, root: str, path: str) -> str:  # type: ignore
+        # find the first absolute path that exists
+        self.root = self.roots[0]
+        abspath = os.path.abspath(os.path.join(root, path))
+        for root in self.roots[1:]:
+            abspath = os.path.abspath(os.path.join(root, path))
+            if os.path.exists(abspath):
+                self.root = root  # make sure all the other methods in the base class know how to find the file
+                break
+
+        # tornado probably already does a version of this, to make sure it behaves as the rest of the solara
+        # server, we do it again
+        if not path_is_child_of(Path(abspath), Path(self.root)):
+            raise PermissionError(f"Trying to read from outside of cache directory: {abspath} is not a subdir of {self.root}")
+
+        return abspath
+
+
+class Assets(MultiStaticFileHandler):
+    def initialize(self):  # type: ignore
+        super().initialize(server.asset_directories())
+        logging.error("Using %r as assets directories", self.roots)
+
+
+class ReadyZ(JupyterHandler):
+    def get(self):
+        json_data, status = server.readyz()
+        json_response = json.dumps(json_data)
+        self.set_header("Content-Type", "application/json")
+        self.set_status(status)
+        self.write(json_response)

solara/server/patch.py

@@ -38,6 +38,7 @@ class FakeIPython:
         # needed for the pyplot interface of matplotlib
         # (although we don't really support it)
         self.events = mock.MagicMock()
+        self.user_ns: Dict[Any, Any] = {}
 
     def enable_gui(self, gui):
         logger.error("ignoring call to enable_gui(%s)", gui)

solara/server/pyinstaller/__init__.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+
+HERE = Path(__file__).parent
+
+
+def get_hook_dirs():
+    # used for pyinstaller
+    return [str(HERE)]

solara/server/pyinstaller/hook-ipyreact.py

@@ -0,0 +1,5 @@
+from PyInstaller.utils.hooks import collect_data_files, copy_metadata, collect_submodules
+
+hiddenimports = collect_submodules("ipyreact")
+datas = collect_data_files("ipyreact")  # codespell:ignore datas
+datas += copy_metadata("ipyreact")  # codespell:ignore datas

solara/server/pyinstaller/hook-ipyvuetify.py

@@ -0,0 +1,5 @@
+from PyInstaller.utils.hooks import collect_data_files, copy_metadata, collect_submodules
+
+hiddenimports = collect_submodules("ipyvuetify")
+datas = collect_data_files("ipyvuetify")  # codespell:ignore datas
+datas += copy_metadata("ipyvuetify")  # codespell:ignore datas

solara/server/pyinstaller/hook-solara.py

@@ -0,0 +1,9 @@
+from PyInstaller.utils.hooks import collect_data_files, collect_submodules
+
+hiddenimports = collect_submodules("solara")
+datas = collect_data_files("solara")  # codespell:ignore datas
+datas += collect_data_files("solara-ui")  # codespell:ignore datas
+
+# this makes sure that inspect.getfile works, which is used for the
+# vue component decorator
+module_collection_mode = "pyz+py"

solara/server/server.py

@@ -6,7 +6,7 @@ import os
 import sys
 import time
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, TypeVar
+from typing import Dict, List, Optional, Tuple, TypeVar, Union
 
 import ipykernel
 import ipyvue
@@ -268,6 +268,7 @@ def asset_directories():
 def read_root(
     path: str,
     root_path: str = "",
+    jupyter_root_path: Union[str, None] = None,
     render_kwargs={},
     use_nbextensions=True,
     ssg_data=None,
@@ -373,10 +374,14 @@ def read_root(
     else:
         cdn = solara.settings.assets.cdn
 
+    if jupyter_root_path is None:
+        jupyter_root_path = f"{root_path}/jupyter"
+
     render_settings = {
         "title": title,
         "path": path,
         "root_path": root_path,
+        "jupyter_root_path": jupyter_root_path,
         "resources": resources,
         "theme": settings.theme.dict(),
         "production": settings.main.mode == "production",

solara/server/starlette.py

@@ -391,16 +391,16 @@ See also https://solara.dev/documentation/getting_started/deploying/self-hosted
 """
         if "script-name" in request.headers:
             msg += f"""It looks like the reverse proxy sets the script-name header to {request.headers['script-name']!r}
-            """
+"""
         if "x-script-name" in request.headers:
             msg += f"""It looks like the reverse proxy sets the x-script-name header to {request.headers['x-script-name']!r}
-            """
+"""
         if configured_root_path:
             msg += f"""It looks like the root path was configured to {configured_root_path!r} in the settings
-            """
+"""
         if root_path_asgi:
             msg += f"""It looks like the root path set by the asgi framework was configured to {root_path_asgi!r}
-            """
+"""
         warnings.warn(msg)
     if host and forwarded_host and forwarded_proto:
         port = request.base_url.port
@@ -451,6 +451,18 @@ See also https://solara.dev/documentation/getting_started/deploying/self-hosted
     if request.scope["scheme"] == "https" or request.headers.get("x-forwarded-proto", "http") == "https" or request.base_url.hostname == "localhost":
         samesite = "none"
         secure = True
+    elif request.base_url.hostname != "localhost":
+        warnings.warn(f"""Cookies with samesite=none require https, but according to the asgi framework, the scheme is {request.scope['scheme']!r}
+and the x-forwarded-proto header is {request.headers.get('x-forwarded-proto', 'http')!r}. We will fallback to samesite=lax.
+
+If you embed solara in an iframe, make sure you forward the x-forwarded-proto header correctly so that the session cookie can be set.
+
+See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite for more information on samesite cookies.
+
+Also check out the following Solara documentation:
+ * https://solara.dev/documentation/getting_started/deploying/self-hosted
+ * https://solara.dev/documentation/advanced/howto/embed
+""")
     response.set_cookie(
         server.COOKIE_KEY_SESSION_ID,
         value=session_id,
@@ -483,9 +495,9 @@ class StaticNbFiles(StaticFilesOptionalAuth):
     # from https://github.com/encode/starlette/pull/1377/files
     def lookup_path(self, path: str) -> typing.Tuple[str, typing.Optional[os.stat_result]]:
         for directory in self.all_directories:
+            directory = os.path.realpath(directory)
             original_path = os.path.join(directory, path)
             full_path = os.path.realpath(original_path)
-            directory = os.path.realpath(directory)
             # return early if someone tries to access a file outside of the directory
             if not path_is_child_of(Path(original_path), Path(directory)):
                 return "", None
@@ -668,7 +680,7 @@ routes = [
     *([Mount(f"/{cdn_url_path}", app=StaticCdn(directory=settings.assets.proxy_cache_dir))] if solara.settings.assets.proxy else []),
     Mount(f"{prefix}/static/public", app=StaticPublic()),
     Mount(f"{prefix}/static/assets", app=StaticAssets()),
-    Mount(f"{prefix}/static/nbextensions", app=StaticNbFiles()),
+    Mount(f"{prefix}/jupyter/nbextensions", app=StaticNbFiles()),
     Mount(f"{prefix}/static", app=StaticFilesOptionalAuth(directory=server.solara_static)),
     Route("/{fullpath:path}", endpoint=root),
 ]

solara/server/static/highlight-dark.css

@@ -2,7 +2,7 @@
    and then remove the overlapping first lines with highlight.css
 */
 .theme--dark.v-application .highlight .hll { background-color: #ffffcc }
-.theme--dark.v-application .highlight { background: #282C34; color: #ABB2BF }
+.theme--dark.v-application .highlight { background: #1d1f22; color: #ABB2BF }
 .theme--dark.v-application .highlight .c { color: #7F848E } /* Comment */
 .theme--dark.v-application .highlight .err { color: #ABB2BF } /* Error */
 .theme--dark.v-application .highlight .esc { color: #ABB2BF } /* Escape */

solara/server/static/main-vuetify.js

@@ -127,7 +127,7 @@ async function solaraInit(mountId, appName) {
             window.navigator.sendBeacon(close_url);
         }
     });
-    let kernel = await solara.connectKernel(solara.rootPath + '/jupyter', kernelId)
+    let kernel = await solara.connectKernel(solara.jupyterRootPath, kernelId)
     if (!kernel) {
         return;
     }

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

solara/server/templates/solara.html.j2

@@ -31,7 +31,7 @@
 
     <script id="jupyter-config-data" type="application/json">
     {
-        "baseUrl": "{{root_path}}/",
+        "baseUrl": "{{jupyter_root_path}}/",
         "kernelId": "1234"
     }
     </script>
@@ -243,12 +243,13 @@
     {% endif %}
     <script>
         solara.rootPath = {{ root_path | tojson | safe}};
+        solara.jupyterRootPath = {{ jupyter_root_path | tojson | safe}};
         solara.cdn = {{ cdn | tojson | safe }};
         // the vue templates expect it to not have a trailing slash
         solara.cdn = solara.cdn.replace(/\/$/, '');
         // keep this for backwards compatibility
         window.solara_cdn = solara.cdn;
-        console.log("rootPath", solara.rootPath);
+        console.log("solara config", {rootPath: solara.rootPath, jupyterRootPath: solara.jupyterRootPath, cdn: solara.cdn});
 
         async function changeThemeCSS(theme) {
             let css = await fetch(`${solara.rootPath}/static/assets/theme-${theme}.css`).then(r => r.text());
@@ -269,6 +270,12 @@
         solara.production = {{ production | tojson | safe }};
         const themeVariants = ['light', 'dark', 'auto']
         solara.preRendered = {{ pre_rendered_html | safe | length | tojson }} > 0
+        if(solara.preRendered) {
+            document.body.classList.add('solara-ssg', 'solara-pre-rendered');
+        } else {
+            document.body.classList.add('solara-no-ssg');
+        }
+
     </script>
 
     <script>
@@ -329,8 +336,25 @@
                     // if preRendered, the app is not mounted yet
                     // so we mount it when loading becomes false
                     if (solara.preRendered && !this.mounted) {
-                        this.isMounted = true;
-                        this.$mount("#app")
+                        function waitForAnimation(element) {
+                            return new Promise((resolve) => {
+                                element.addEventListener('animationend', resolve, { once: true });
+                            });
+                        }
+
+                        function waitForAllAnimations(elements) {
+                            const animationPromises = Array.from(elements).map(element => waitForAnimation(element));
+                            return Promise.all(animationPromises);
+                        }
+
+                        (async () => {
+                            await waitForAllAnimations(document.querySelectorAll('.solara-ssg-wait-for-animation'));
+                            console.log("animation finished");
+                            document.body.classList.remove('solara-pre-rendered');
+                            document.body.classList.add('solara-pre-rendered-finished');
+                            this.isMounted = true;
+                            this.$mount("#app")
+                        })();
                     } else {
                         this.isMounted = true;
                     }
@@ -418,7 +442,7 @@
         {% endif -%}
         nbextensionHashes = {{ resources.nbextensions_hashes | tojson | safe }};
         requirejs.config({
-            baseUrl: '{{root_path}}/static/',
+            baseUrl: '{{jupyter_root_path}}',
             waitSeconds: 3000,
             map: {
                 '*': {
@@ -443,7 +467,7 @@
             });
         requirejs([
             {% for ext in resources.nbextensions if ext != 'jupyter-vuetify/extension' and ext != 'jupyter-vue/extension' -%}
-        "{{root_path}}/static/nbextensions/{{ ext }}.js",
+        "{{jupyter_root_path}}/nbextensions/{{ ext }}.js",
             {% endfor %}
         ]);
         (async function () {