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

solara/components/spinner.py

@@ -8,12 +8,15 @@ class SpinnerSolaraWidget(ipyvue.VueTemplate):
     template_file = (__file__, "spinner-solara.vue")
 
     size = traitlets.Unicode("64px").tag(sync=True)
+    color_back = traitlets.Unicode("#FFCF64").tag(sync=True)
+    color_front = traitlets.Unicode("#FF8C3E").tag(sync=True)
 
 
 @solara.component
-def SpinnerSolara(size="64px"):
+def SpinnerSolara(size="64px", color_back="#FFCF64", color_front="#FF8C3E"):
     """Spinner component with the Solara logo to indicate the app is busy.
 
+    ## Examples
     ### Basic example
 
     ```solara
@@ -24,7 +27,19 @@ def SpinnerSolara(size="64px"):
         solara.SpinnerSolara(size="100px")
     ```
 
+    ## Changing the colors
+    ```solara
+    import solara
+
+    @solara.component
+    def Page():
+        solara.SpinnerSolara(size="100px", color_back="Grey", color_front="Lime")
+    ```
+
+
     ## Arguments
      * `size`: Size of the spinner.
+     * `color_back`: Color of the spinner in the background.
+     * `color_front`: Color of the spinner in the foreground.
     """
-    return SpinnerSolaraWidget.element(size=size)
+    return SpinnerSolaraWidget.element(size=size, color_back=color_back, color_front=color_front)

solara/hooks/use_reactive.py

@@ -1,4 +1,4 @@
-from typing import Callable, Optional, TypeVar, Union
+from typing import Any, Callable, Optional, TypeVar, Union
 
 import solara
 
@@ -8,6 +8,7 @@ T = TypeVar("T")
 def use_reactive(
     value: Union[T, solara.Reactive[T]],
     on_change: Optional[Callable[[T], None]] = None,
+    equals: Callable[[Any, Any], bool] = solara.util.equals_extra,
 ) -> solara.Reactive[T]:
     """Creates a reactive variable with the a local component scope.
 
@@ -44,6 +45,12 @@ def use_reactive(
      * on_change (Optional[Callable[[T], None]]): An optional callback function
             that will be called when the reactive variable's value changes.
 
+     * equals: A function that returns True if two values are considered equal, and False otherwise.
+            The default function is `solara.util.equals`, which performs a deep comparison of the two values
+            and is more forgiving than the default `==` operator.
+            You can provide a custom function if you need to define a different notion of equality.
+
+
     Returns:
         solara.Reactive[T]: A reactive variable with the specified initial value
             or the provided reactive variable.

solara/reactive.py

@@ -1,13 +1,14 @@
-from typing import TypeVar
+from typing import Any, Callable, TypeVar
 
 from solara.toestand import Reactive
+import solara.util
 
 __all__ = ["reactive", "Reactive"]
 
 T = TypeVar("T")
 
 
-def reactive(value: T) -> Reactive[T]:
+def reactive(value: T, equals: Callable[[Any, Any], bool] = solara.util.equals_extra) -> Reactive[T]:
     """Creates a new Reactive object with the given initial value.
 
     Reactive objects are mostly used to manage global or application-wide state in
@@ -35,6 +36,11 @@ def reactive(value: T) -> Reactive[T]:
 
     Args:
         value (T): The initial value of the reactive variable.
+        equals: A function that returns True if two values are considered equal, and False otherwise.
+            The default function is `solara.util.equals`, which performs a deep comparison of the two values
+            and is more forgiving than the default `==` operator.
+            You can provide a custom function if you need to define a different notion of equality.
+
 
     Returns:
         Reactive[T]: A new Reactive object with the specified initial value.
@@ -90,4 +96,4 @@ def reactive(value: T) -> Reactive[T]:
     Whenever the counter value changes, `CounterDisplay` automatically updates to display the new value.
 
     """
-    return Reactive(value)
+    return Reactive(value, equals=equals)

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 {
@@ -124,6 +125,7 @@ div.highlight {
 
 .solara-autorouter-content {
     height: 100%;
+    max-width: 100%;
 }
 
 /* originally from index.css */

solara/server/kernel.py

@@ -2,6 +2,7 @@ import json
 import logging
 import pdb
 import queue
+import re
 import struct
 import warnings
 from binascii import b2a_base64
@@ -73,7 +74,7 @@ def json_dumps(data):
     )
 
 
-ipykernel_version = tuple(map(int, ipykernel.__version__.split(".")))
+ipykernel_version = tuple(map(int, re.split(r"\D+", ipykernel.__version__)[:3]))
 if ipykernel_version >= (6, 18, 0):
     import comm.base_comm
 

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(["Solara App"])
+    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/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_"

solara/server/starlette.py

@@ -86,8 +86,8 @@ prefix = ""
 # Since starlette seems to accept really large values for http, lets do the same for websockets
 # An arbitrarily large value we settled on for now is 32kb
 # If we don't do this, users with many cookies will fail to get a websocket connection.
-ws_version = tuple(map(int, websockets.__version__.split(".")))
-if ws_version[0] >= 13:
+ws_major_version = int(websockets.__version__.split(".")[0])
+if ws_major_version >= 13:
     websockets.legacy.http.MAX_LINE_LENGTH = int(os.environ.get("WEBSOCKETS_MAX_LINE_LENGTH", str(1024 * 32)))  # type: ignore
 else:
     websockets.legacy.http.MAX_LINE = 1024 * 32  # type: ignore

solara/server/static/main-vuetify.js

@@ -138,15 +138,25 @@ async function solaraInit(mountId, appName) {
     });
 
     window.addEventListener('solara.router', function (event) {
+        app.$data.urlHasChanged = true;
         if(kernel.status == 'busy') {
             app.$data.loadingPage = true;
         }
     });
     kernel.statusChanged.connect(() => {
+        // When navigation is triggered from the front-end, kernel.status becoming busy and
+        // solara.router event happen in a different order than when navigating through Python, so
+        // if the URL has changed when the kernel becomes busy, we set loadingPage to true
+        if (kernel.status == 'busy' && app.$data.urlHasChanged) {
+            app.$data.loadingPage = true;
+        }
         // the first idle after a loadingPage == true (a router event)
         // will be used as indicator that the page is loaded
         if (app.$data.loadingPage && kernel.status == 'idle') {
             app.$data.loadingPage = false;
+            app.$data.urlHasChanged = false;
+            const event = new Event('solara.pageReady');
+            window.dispatchEvent(event);
         }
     });
 

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

solara/server/templates/loader-solara.html

@@ -32,7 +32,7 @@
         <jupyter-widget-mount-point mount-id="solara-main">
             A widget with mount-id="solara-main" should go here
         </jupyter-widget-mount-point>
-        <div style="position: absolute; right: 0px; bottom: 0px; padding: 10px;">
+        <div v-if="showBanner" style="position: absolute; right: 0px; bottom: 0px; padding: 10px;">
             <b>This website runs on <a href="https://solara.dev">Solara</a></b>
         </div>
     </div>

solara/server/templates/solara.html.j2

@@ -172,7 +172,7 @@
 </script>
 {% endraw -%}
 
-<body data-base-url="{{root_path}}/static/">
+<body data-base-url="{{root_path}}/jupyter/">
     {% if perform_check %}
     <iframe src="https://solara.dev/static/public/success.html?system=solara&check=html&version={{solara_version}}" style="display: none"></iframe>
     {% endif %}
@@ -296,6 +296,10 @@
                     this.forceUpdateTrigger += 1;
                     original_$forceUpdate();
                 });
+                // in case we are showing a popop (e.g. using ipypopout), hide the banner
+                if(searchParams.has('modelid')) {
+                    this.showBanner = false;
+                }
             },
             mounted() {
                 document.querySelector('#app').removeAttribute("style");
@@ -413,6 +417,7 @@
                     loadingPage: false,
                     _lastBusyTimer: null,
                     kernelBusyLong: false,
+                    showBanner: theme.show_banner,
                     // outputMessages: [{ name: 'stderr', text: 'lala' }],
                 }
             }

solara/settings.py

@@ -61,9 +61,23 @@ class MainSettings(BaseSettings):
         env_file = ".env"
 
 
+class Storage(BaseSettings):
+    mutation_detection: Optional[bool] = None  # True/False, or None to auto determine
+    factory: str = "solara.toestand.default_storage"
+
+    def get_factory(self):
+        return solara.util.import_item(self.factory)
+
+    class Config:
+        env_prefix = "solara_storage_"
+        case_sensitive = False
+        env_file = ".env"
+
+
 assets: Assets = Assets()
 cache: Cache = Cache()
 main = MainSettings()
+storage = Storage()
 
 if main.check_hooks not in ["off", "warn", "raise"]:
     raise ValueError(f"Invalid value for check_hooks: {main.check_hooks}, expected one of ['off', 'warn', 'raise']")

solara/template/portal/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling >=0.25"]
+requires = ["hatchling==1.26.3"]
 build-backend = "hatchling.build"
 
 [project]

solara/test/pytest_plugin.py

@@ -515,6 +515,8 @@ def create_runner_solara(solara_server, solara_app, page_session: "playwright.sy
 
     def run(f: Callable, locals={}):
         nonlocal count
+        from IPython.display import clear_output
+
         path = Path(f.__code__.co_filename)
         cwd = str(path.parent)
         current_dir = os.getcwd()
@@ -523,6 +525,7 @@ def create_runner_solara(solara_server, solara_app, page_session: "playwright.sy
 
         sys.path.append(cwd)
         try:
+            clear_output()
             f()
         finally:
             os.chdir(current_dir)

solara/toestand.py

@@ -1,9 +1,13 @@
 import contextlib
 import dataclasses
+import inspect
 import logging
+import os
 import sys
 import threading
+from types import FrameType
 import warnings
+import copy
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from operator import getitem
@@ -24,9 +28,10 @@ from typing import (
 
 import react_ipywidgets as react
 import reacton.core
-from reacton.utils import equals
+from solara.util import equals_extra
 
 import solara
+import solara.settings
 from solara import _using_solara_server
 
 T = TypeVar("T")
@@ -61,7 +66,7 @@ def use_sync_external_store(subscribe: Callable[[Callable[[], None]], Callable[[
 
     def on_store_change(_ignore_new_state=None):
         new_state = get_snapshot()
-        if not equals(new_state, prev_state.current):
+        if not equals_extra(new_state, prev_state.current):
             prev_state.current = new_state
             force_update()
 
@@ -87,8 +92,9 @@ def merge_state(d1: S, **kwargs) -> S:
 
 
 class ValueBase(Generic[T]):
-    def __init__(self, merge: Callable = merge_state):
+    def __init__(self, merge: Callable = merge_state, equals=equals_extra):
         self.merge = merge
+        self.equals = equals
         self.listeners: Dict[str, Set[Tuple[Callable[[T], None], Optional[ContextManager]]]] = defaultdict(set)
         self.listeners2: Dict[str, Set[Tuple[Callable[[T, T], None], Optional[ContextManager]]]] = defaultdict(set)
 
@@ -199,8 +205,8 @@ class KernelStore(ValueBase[S], ABC):
     _type_counter: Dict[Any, int] = defaultdict(int)
     scope_lock = threading.RLock()
 
-    def __init__(self, key=None):
-        super().__init__()
+    def __init__(self, key=None, equals: Callable[[Any, Any], bool] = equals_extra):
+        super().__init__(equals=equals)
         self.storage_key = key
         self._global_dict = {}
         # since a set can trigger events, which can trigger new updates, we need a recursive lock
@@ -250,7 +256,7 @@ class KernelStore(ValueBase[S], ABC):
     def set(self, value: S):
         scope_dict, scope_id = self._get_dict()
         old = self.get()
-        if equals(old, value):
+        if self.equals(old, value):
             return
         scope_dict[self.storage_key] = value
 
@@ -268,23 +274,114 @@ class KernelStore(ValueBase[S], ABC):
     def initial_value(self) -> S:
         pass
 
+    def _check_mutation(self):
+        pass
+
+
+def _is_internal_module(file_name: str):
+    file_name_parts = file_name.split(os.sep)
+    if len(file_name_parts) < 2:
+        return False
+    return (
+        file_name_parts[-2:] == ["solara", "toestand.py"]
+        or file_name_parts[-2:] == ["solara", "reactive.py"]
+        or file_name_parts[-2:] == ["solara", "use_reactive.py"]
+        or file_name_parts[-2:] == ["reacton", "core.py"]
+        # If we use SomeClass[K](...) we go via the typing module, so we need to skip that as well
+        or (file_name_parts[-2].startswith("python") and file_name_parts[-1] == "typing.py")
+    )
+
+
+def _find_outside_solara_frame() -> Optional[FrameType]:
+    # the module where the call stack origined from
+    current_frame: Optional[FrameType] = None
+    module_frame = None
+
+    # _getframe is not guaranteed to exist in all Python implementations,
+    # but is much faster than the inspect module
+    if hasattr(sys, "_getframe"):
+        current_frame = sys._getframe(1)
+    else:
+        current_frame = inspect.currentframe()
+
+    while current_frame is not None:
+        file_name = current_frame.f_code.co_filename
+        # Skip most common cases, i.e. toestand.py, reactive.py, use_reactive.py, Reacton's core.py, and the typing module
+        if not _is_internal_module(file_name):
+            module_frame = current_frame
+            break
+        current_frame = current_frame.f_back
+
+    return module_frame
+
 
 class KernelStoreValue(KernelStore[S]):
     default_value: S
+    _traceback: Optional[inspect.Traceback]
+    _default_value_copy: Optional[S]
 
-    def __init__(self, default_value: S, key=None):
+    def __init__(self, default_value: S, key=None, equals: Callable[[Any, Any], bool] = equals_extra, unwrap=lambda x: x):
         self.default_value = default_value
+        self._unwrap = unwrap
+        self.equals = equals
+        self._mutation_detection = solara.settings.storage.mutation_detection
+        if self._mutation_detection:
+            frame = _find_outside_solara_frame()
+            if frame is not None:
+                self._traceback = inspect.getframeinfo(frame)
+            else:
+                self._traceback = None
+            self._default_value_copy = copy.deepcopy(default_value)
+            if not self.equals(self._unwrap(self.default_value), self._unwrap(self._default_value_copy)):
+                msg = """The equals function for this reactive value returned False when comparing a deepcopy to itself.
+
+This reactive variable will not be able to detect mutations correctly, and is therefore disabled.
+
+To avoid this warning, and to ensure that mutation detection works correctly, please provide a better equals function to the reactive variable.
+A good choice for dataframes and numpy arrays might be solara.util.equals_pickle, which will also attempt to compare the pickled values of the objects.
+
+Example:
+df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
+"""
+                tb = self._traceback
+                if tb:
+                    if tb.code_context:
+                        code = tb.code_context[0]
+                    else:
+                        code = "<No code context available>"
+                    msg += "This warning was triggered from:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
+                warnings.warn(msg)
+                self._mutation_detection = False
         cls = type(default_value)
         if key is None:
             with KernelStoreValue.scope_lock:
                 index = self._type_counter[cls]
                 self._type_counter[cls] += 1
             key = cls.__module__ + ":" + cls.__name__ + ":" + str(index)
-        super().__init__(key=key)
+        super().__init__(key=key, equals=equals)
 
     def initial_value(self) -> S:
+        self._check_mutation()
         return self.default_value
 
+    def _check_mutation(self):
+        if not self._mutation_detection:
+            return
+        initial = self._unwrap(self._default_value_copy)
+        current = self._unwrap(self.default_value)
+        if not self.equals(initial, current):
+            tb = self._traceback
+            if tb:
+                if tb.code_context:
+                    code = tb.code_context[0].strip()
+                else:
+                    code = "No code context available"
+                msg = f"Reactive variable was initialized at {tb.filename}:{tb.lineno} with {initial!r}, but was mutated to {current!r}.\n" f"{code}"
+            else:
+                msg = f"Reactive variable was initialized with a value of {initial!r}, but was mutated to {current!r} (unable to report the location in the source code)."
+            raise ValueError(msg)
+
 
 def _create_key_callable(f: Callable[[], S]):
     try:
@@ -302,22 +399,48 @@ def _create_key_callable(f: Callable[[], S]):
 
 
 class KernelStoreFactory(KernelStore[S]):
-    def __init__(self, factory: Callable[[], S], key=None):
+    def __init__(self, factory: Callable[[], S], key=None, equals: Callable[[Any, Any], bool] = equals_extra):
         self.factory = factory
         key = key or _create_key_callable(factory)
-        super().__init__(key=key)
+        super().__init__(key=key, equals=equals)
 
     def initial_value(self) -> S:
         return self.factory()
 
 
+def mutation_detection_storage(default_value: S, key=None, equals=None) -> ValueBase[S]:
+    from solara.util import equals_pickle as default_equals
+    from ._stores import MutateDetectorStore, StoreValue, _PublicValueNotSet
+
+    kernel_store = KernelStoreValue[StoreValue[S]](
+        StoreValue[S](private=default_value, public=_PublicValueNotSet(), get_traceback=None, set_value=None, set_traceback=None),
+        key=key,
+        unwrap=lambda x: x.private,
+    )
+    return MutateDetectorStore[S](kernel_store, equals=equals or default_equals)
+
+
+def default_storage(default_value: S, key=None, equals=None) -> ValueBase[S]:
+    # in solara v2 we will also do this when mutation_detection is None
+    # and we do not run on production mode
+    if solara.settings.storage.mutation_detection is True:
+        return mutation_detection_storage(default_value, key=key, equals=equals)
+    else:
+        return KernelStoreValue[S](default_value, key=key, equals=equals or equals_extra)
+
+
+def _call_storage_factory(default_value: S, key=None, equals=None) -> ValueBase[S]:
+    factory = solara.settings.storage.get_factory()
+    return factory(default_value, key=key, equals=equals)
+
+
 class Reactive(ValueBase[S]):
     _storage: ValueBase[S]
 
-    def __init__(self, default_value: Union[S, ValueBase[S]], key=None):
+    def __init__(self, default_value: Union[S, ValueBase[S]], key=None, equals=None):
         super().__init__()
         if not isinstance(default_value, ValueBase):
-            self._storage = KernelStoreValue(default_value, key=key)
+            self._storage = _call_storage_factory(default_value, key=key, equals=equals)
         else:
             self._storage = default_value
         self.__post__init__()
@@ -505,11 +628,11 @@ def computed(
 
 
 class ReactiveField(Reactive[T]):
-    def __init__(self, field: "FieldBase"):
+    def __init__(self, field: "FieldBase", equals: Callable[[Any, Any], bool] = equals_extra):
         # super().__init__()  # type: ignore
         # We skip the Reactive constructor, because we do not need it, but we do
         # want to be an instanceof for use in use_reactive
-        ValueBase.__init__(self)
+        ValueBase.__init__(self, equals=equals)
         self._field = field
         field = field
         while not isinstance(field, ValueBase):
@@ -536,7 +659,7 @@ class ReactiveField(Reactive[T]):
             except KeyError:
                 return  # same
             old_value = self._field.get(old)
-            if not equals(new_value, old_value):
+            if not self.equals(new_value, old_value):
                 listener(new_value)
 
         return self._root.subscribe_change(on_change, scope=scope)
@@ -550,7 +673,7 @@ class ReactiveField(Reactive[T]):
             except KeyError:
                 return  # see subscribe
             old_value = self._field.get(old)
-            if not equals(new_value, old_value):
+            if not self.equals(new_value, old_value):
                 listener(new_value, old_value)
 
         return self._root.subscribe_change(on_change, scope=scope)