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

solara/__init__.py

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

solara/__main__.py

@@ -261,6 +261,12 @@ if "SOLARA_MODE" in os.environ:
     default=True,
     help="Check installed version again pypi version.",
 )
+@click.option(
+    "--qt",
+    is_flag=True,
+    default=False,
+    help="Instead of opening a browser, open a Qt window. Will also stop the server when the window is closed. (experimental)",
+)
 def run(
     app,
     host,
@@ -290,6 +296,7 @@ def run(
     ssg: bool,
     search: bool,
     check_version: bool = True,
+    qt=False,
 ):
     """Run a Solara app."""
     if dev is not None:
@@ -365,9 +372,16 @@ def run(
         while not failed and (server is None or not server.started):
             time.sleep(0.1)
         if not failed:
-            webbrowser.open(url)
+            if qt:
+                from .server.qt import run_qt
 
-    if open:
+                run_qt(url)
+            else:
+                webbrowser.open(url)
+
+    # with qt, we open the browser in the main thread (qt wants that)
+    # otherwise, we open the browser in a separate thread
+    if open and not qt:
         threading.Thread(target=open_browser, daemon=True).start()
 
     rich.print(f"Solara server is starting at {url}")
@@ -397,7 +411,7 @@ def run(
     settings.main.timing = timing
     items = (
         "theme_variant_user_selectable dark theme_variant theme_loader use_pdb server open_browser open url failed dev tracer"
-        " timing ssg search check_version production".split()
+        " timing ssg search check_version production qt".split()
     )
     for item in items:
         del kwargs[item]
@@ -451,14 +465,13 @@ def run(
 
         build_index("")
 
-    start_server()
-
     # TODO: if we want to use webview, it should be sth like this
-    # server_thread = threading.Thread(target=start_server)
-    # server_thread.start()
-    # if open:
-    #     # open_webview()
-    #     open_browser()
+    if qt:
+        server_thread = threading.Thread(target=start_server, daemon=True)
+        server_thread.start()
+        open_browser()
+    else:
+        start_server()
     # server_thread.join()
 
 

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/component_vue.py

@@ -1,4 +1,5 @@
 import inspect
+import os
 from typing import Any, Callable, Dict, Type
 
 import ipyvue as vue
@@ -48,10 +49,10 @@ def _widget_from_signature(classname, base_class: Type[widgets.Widget], func: Ca
 def _widget_vue(vue_path: str, vuetify=True) -> Callable[[Callable[P, None]], Type[v.VuetifyTemplate]]:
     def decorator(func: Callable[P, None]):
         class VuetifyWidgetSolara(v.VuetifyTemplate):
-            template_file = (inspect.getfile(func), vue_path)
+            template_file = (os.path.abspath(inspect.getfile(func)), vue_path)
 
         class VueWidgetSolara(vue.VueTemplate):
-            template_file = (inspect.getfile(func), vue_path)
+            template_file = (os.path.abspath(inspect.getfile(func)), vue_path)
 
         base_class = VuetifyWidgetSolara if vuetify else VueWidgetSolara
         widget_class = _widget_from_signature("VueWidgetSolaraSub", base_class, func, "vue_")

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

@@ -1,6 +1,7 @@
 html {
   /* override vuetify's css reset ress.css */
   overflow-y: auto;
+  scroll-behavior: smooth;
 }
 
 .jupyter-widgets code {
@@ -75,7 +76,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;
@@ -123,6 +125,7 @@ div.highlight {
 
 .solara-autorouter-content {
     height: 100%;
+    max-width: 100%;
 }
 
 /* originally from index.css */

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/qt.py

@@ -0,0 +1,113 @@
+import sys
+from typing import List
+import webbrowser
+from qtpy.QtWidgets import QApplication
+from qtpy.QtWebEngineWidgets import QWebEngineView
+from qtpy.QtWebChannel import QWebChannel
+from qtpy import QtCore, QtGui
+import signal
+from pathlib import Path
+
+HERE = Path(__file__).parent
+
+
+# setUrlRequestInterceptor, navigationRequested and acceptNavigationRequest
+# all trigger the websocket to disconnect, so we need to block cross origin
+# requests on the frontend/browser side by intercepting clicks on links
+
+cross_origin_block_js = """
+var script = document.createElement('script');
+script.src = 'qrc:///qtwebchannel/qwebchannel.js';
+document.head.appendChild(script);
+script.onload = function() {
+    new QWebChannel(qt.webChannelTransport, function(channel) {
+        let py_callback = channel.objects.py_callback;
+
+        document.addEventListener('click', function(event) {
+            let target = event.target;
+            while (target && target.tagName !== 'A') {
+                target = target.parentNode;
+            }
+
+            if (target && target.tagName === 'A') {
+                const linkOrigin = new URL(target.href).origin;
+                const currentOrigin = window.location.origin;
+
+                if (linkOrigin !== currentOrigin) {
+                    event.preventDefault();
+                    console.log("Blocked cross-origin navigation to:", target.href);
+                    py_callback.open_link(target.href);  // Call Python method
+                }
+            }
+        }, true);
+    });
+};
+"""
+
+
+class PyCallback(QtCore.QObject):
+    @QtCore.Slot(str)
+    def open_link(self, url):
+        webbrowser.open(url)
+
+
+class QWebEngineViewWithPopup(QWebEngineView):
+    # keep a strong reference to all windows
+    windows: List = []
+
+    def __init__(self):
+        super().__init__()
+        self.page().newWindowRequested.connect(self.handle_new_window_request)
+
+        # Set up WebChannel and py_callback object
+        self.py_callback = PyCallback()
+        self.channel = QWebChannel()
+        self.channel.registerObject("py_callback", self.py_callback)
+        self.page().setWebChannel(self.channel)
+
+        self.loadFinished.connect(self._inject_javascript)
+
+    def _inject_javascript(self, ok):
+        self.page().runJavaScript(cross_origin_block_js)
+
+    def handle_new_window_request(self, info):
+        webview = QWebEngineViewWithPopup()
+        geometry = info.requestedGeometry()
+        webview.resize(geometry.width(), geometry.height())
+        webview.setUrl(info.requestedUrl())
+        webview.show()
+        QWebEngineViewWithPopup.windows.append(webview)
+        return webview
+
+
+def run_qt(url):
+    app = QApplication([])
+    web = QWebEngineViewWithPopup()
+    web.setUrl(QtCore.QUrl(url))
+    web.resize(1024, 1024)
+    web.show()
+
+    app_name = "Solara"
+    app.setApplicationDisplayName(app_name)
+    app.setApplicationName(app_name)
+    web.setWindowTitle(app_name)
+    app.setWindowIcon(QtGui.QIcon(str(HERE.parent / "website/public/logo.svg")))
+    if sys.platform.startswith("darwin"):
+        # Set app name, if PyObjC is installed
+        # Python 2 has PyObjC preinstalled
+        # Python 3: pip3 install pyobjc-framework-Cocoa
+        try:
+            from Foundation import NSBundle
+
+            bundle = NSBundle.mainBundle()
+            if bundle:
+                app_info = bundle.localizedInfoDictionary() or bundle.infoDictionary()
+                if app_info is not None:
+                    app_info["CFBundleName"] = app_name
+                    app_info["CFBundleDisplayName"] = app_name
+        except ModuleNotFoundError:
+            pass
+
+    # without this, ctrl-c does not work in the terminal
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+    app.exec_()

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/settings.py

@@ -37,6 +37,7 @@ class ThemeVariant(str, Enum):
 class ThemeSettings(BaseSettings):
     variant: ThemeVariant = ThemeVariant.light
     loader: str = "solara"
+    show_banner: bool = True
 
     class Config:
         env_prefix = "solara_theme_"