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

solara/server/shell.py

@@ -1,3 +1,4 @@
+import atexit
 import io
 import sys
 from binascii import b2a_base64
@@ -58,9 +59,12 @@ class SolaraDisplayPublisher(DisplayPublisher):
         self,
         data,
         metadata=None,
+        source=None,
+        *,  # Enforce keyword-only arguments to match DisplayPublisher.publish
         transient=None,
         update=False,
-    ):
+        **kwargs,  # Make sure we're compatible with DisplayPublisher.publish
+    ) -> None:
         """Publish a display-data message
 
         Parameters
@@ -180,10 +184,24 @@ class SolaraInteractiveShell(InteractiveShell):
     history_manager = Any()  # type: ignore
     display_pub: SolaraDisplayPublisher
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        atexit.unregister(self.atexit_operations)
+
+        if self.magics_manager:
+            magic = self.magics_manager.registry["ScriptMagics"]
+            atexit.unregister(magic.kill_bg_processes)
+
     def set_parent(self, parent):
         """Tell the children about the parent message."""
         self.display_pub.set_parent(parent)
 
+    def init_sys_modules(self):
+        pass  # don't create a __main__, it will cause a mem leak
+
+    def init_prefilter(self):
+        pass  # avoid consuming memory
+
     def init_history(self):
         self.history_manager = Mock()  # type: ignore
 

solara/server/starlette.py

@@ -15,6 +15,7 @@ import anyio
 import starlette.websockets
 import uvicorn.server
 import websockets.legacy.http
+import websockets.exceptions
 
 from solara.server.utils import path_is_child_of
 
@@ -86,8 +87,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
@@ -121,37 +122,55 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
             while len(self.to_send) > 0:
                 first = self.to_send.pop(0)
                 if isinstance(first, bytes):
-                    await self.ws.send_bytes(first)
+                    await self._send_bytes_exc(first)
                 else:
-                    await self.ws.send_text(first)
+                    await self._send_text_exc(first)
+
+    async def _send_bytes_exc(self, data: bytes):
+        # make sures we catch the starlette/websockets specific exception
+        # and re-raise it as a websocket.WebSocketDisconnect
+        try:
+            await self.ws.send_bytes(data)
+        except (websockets.exceptions.ConnectionClosed, starlette.websockets.WebSocketDisconnect, RuntimeError) as e:
+            # starlette throws a RuntimeError once you call send after the connection is closed
+            raise websocket.WebSocketDisconnect() from e
+
+    async def _send_text_exc(self, data: str):
+        # make sures we catch the starlette/websockets specific exception
+        # and re-raise it as a websocket.WebSocketDisconnect
+        try:
+            await self.ws.send_text(data)
+        except (websockets.exceptions.ConnectionClosed, starlette.websockets.WebSocketDisconnect, RuntimeError) as e:
+            # starlette throws a RuntimeError once you call send after the connection is closed
+            raise websocket.WebSocketDisconnect() from e
 
     def close(self):
         if self.portal is None:
             asyncio.ensure_future(self.ws.close())
         else:
-            self.portal.call(self.ws.close)  # type: ignore
+            self.portal.call(self.ws.close)
 
     def send_text(self, data: str) -> None:
         if self.portal is None:
-            task = self.event_loop.create_task(self.ws.send_text(data))
+            task = self.event_loop.create_task(self._send_text_exc(data))
             self.tasks.add(task)
             task.add_done_callback(self.tasks.discard)
         else:
             if settings.main.experimental_performance:
                 self.to_send.append(data)
             else:
-                self.portal.call(self.ws.send_bytes, data)  # type: ignore
+                self.portal.call(self._send_text_exc, data)
 
     def send_bytes(self, data: bytes) -> None:
         if self.portal is None:
-            task = self.event_loop.create_task(self.ws.send_bytes(data))
+            task = self.event_loop.create_task(self._send_bytes_exc(data))
             self.tasks.add(task)
             task.add_done_callback(self.tasks.discard)
         else:
             if settings.main.experimental_performance:
                 self.to_send.append(data)
             else:
-                self.portal.call(self.ws.send_bytes, data)  # type: ignore
+                self.portal.call(self._send_bytes_exc, data)
 
     async def receive(self):
         if self.portal is None:
@@ -159,9 +178,9 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
         else:
             if hasattr(self.portal, "start_task_soon"):
                 # version 3+
-                fut = self.portal.start_task_soon(self.ws.receive)  # type: ignore
+                fut = self.portal.start_task_soon(self.ws.receive)
             else:
-                fut = self.portal.spawn_task(self.ws.receive)  # type: ignore
+                fut = self.portal.spawn_task(self.ws.receive)
 
             message = await asyncio.wrap_future(fut)
         if "text" in message:
@@ -444,6 +463,7 @@ See also https://solara.dev/documentation/getting_started/deploying/self-hosted
     session_id = request.cookies.get(server.COOKIE_KEY_SESSION_ID) or str(uuid4())
     samesite = "lax"
     secure = False
+    httponly = settings.session.http_only
     # we want samesite, so we can set a cookie when embedded in an iframe, such as on huggingface
     # however, samesite=none requires Secure https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite
     # when hosted on the localhost domain we can always set the Secure flag
@@ -469,6 +489,7 @@ Also check out the following Solara documentation:
         expires="Fri, 01 Jan 2038 00:00:00 GMT",
         samesite=samesite,  # type: ignore
         secure=secure,  # type: ignore
+        httponly=httponly,  # type: ignore
     )  # type: ignore
     return response
 
@@ -549,12 +570,19 @@ class StaticCdn(StaticFilesOptionalAuth):
 
 
 def on_startup():
+    appmod.ensure_apps_initialized()
     # TODO: configure and set max number of threads
     # see https://github.com/encode/starlette/issues/1724
     telemetry.server_start()
 
 
 def on_shutdown():
+    # shutdown all kernels
+    for context in list(kernel_context.contexts.values()):
+        try:
+            context.close()
+        except:  # noqa
+            logger.exception("error closing kernel on shutdown")
     telemetry.server_stop()
 
 

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

solara/settings.py

@@ -54,6 +54,9 @@ class Assets(BaseSettings):
 
 class MainSettings(BaseSettings):
     check_hooks: str = "warn"
+    allow_reactive_boolean: bool = True
+    # TODO: also change default_container in solara/components/__init__.py
+    default_container: Optional[str] = "Column"
 
     class Config:
         env_prefix = "solara_"
@@ -61,9 +64,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/tasks.py

@@ -1,3 +1,4 @@
+import sys
 import abc
 import asyncio
 import dataclasses
@@ -27,6 +28,12 @@ from solara.toestand import Singleton
 
 from .toestand import Ref as ref
 
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+
 R = TypeVar("R")
 T = TypeVar("T")
 P = typing_extensions.ParamSpec("P")
@@ -686,24 +693,27 @@ def task(
         return wrapper(f)
 
 
+# Quotes around Task[...] are needed in Python <= 3.9, since ParamSpec doesn't properly support non-type arguments
+# i.e. [] is taken as a value instead of a type
+# See https://github.com/python/typing_extensions/issues/126 and related issues
 @overload
 def use_task(
     f: None = None,
     *,
-    dependencies: None = ...,
+    dependencies: Literal[None] = ...,
     raise_error=...,
     prefer_threaded=...,
-) -> Callable[[Callable[P, R]], Task[P, R]]: ...
+) -> Callable[[Callable[[], R]], "Task[[], R]"]: ...
 
 
 @overload
 def use_task(
-    f: Callable[P, R],
+    f: Callable[[], R],
     *,
-    dependencies: None = ...,
+    dependencies: Literal[None] = ...,
     raise_error=...,
     prefer_threaded=...,
-) -> Task[P, R]: ...
+) -> "Task[[], R]": ...
 
 
 @overload
@@ -727,12 +737,12 @@ def use_task(
 
 
 def use_task(
-    f: Union[None, Callable[P, R]] = None,
+    f: Union[None, Callable[[], R]] = None,
     *,
     dependencies: Union[None, List] = [],
     raise_error=True,
     prefer_threaded=True,
-) -> Union[Callable[[Callable[P, R]], Task[P, R]], Task[P, R]]:
+) -> Union[Callable[[Callable[[], R]], "Task[[], R]"], "Task[[], R]"]:
     """A hook that runs a function or coroutine function as a task and returns the result.
 
     Allows you to run code in the background, with the UI available to the user. This is useful for long running tasks,
@@ -811,7 +821,7 @@ def use_task(
     """
 
     def wrapper(f):
-        def create_task() -> Task[P, R]:
+        def create_task() -> "Task[[], R]":
             return task(f, prefer_threaded=prefer_threaded)
 
         task_instance = solara.use_memo(create_task, dependencies=[])

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

@@ -150,6 +150,7 @@ def solara_app(solara_server):
             solara.server.app.apps["__default__"].close()
         if isinstance(app, str):
             app = solara.server.app.AppScript(app)
+            app.init()
         used_app = app
         solara.server.app.apps["__default__"] = app
         try:
@@ -515,6 +516,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 +526,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,11 +92,43 @@ 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)
 
+    # make sure all boolean operations give type errors
+    if not solara.settings.main.allow_reactive_boolean:
+
+        def __bool__(self):
+            raise TypeError("Reactive vars are not allowed in boolean expressions, did you mean to use .value?")
+
+        def __eq__(self, other):
+            raise TypeError(f"'==' not supported between a Reactive and {other.__class__.__name__}, did you mean to use .value?")
+
+        def __ne__(self, other):
+            raise TypeError(f"'!=' not supported between a Reactive and {other.__class__.__name__}, did you mean to use .value?")
+
+        # If we explicitly define __eq__, we need to explicitly define __hash__ as well
+        # Otherwise our class is marked unhashable
+        __hash__ = object.__hash__
+
+    def __lt__(self, other):
+        raise TypeError(f"'<' not supported between a Reactive and {other.__class__.__name__}, did you mean to use .value?")
+
+    def __le__(self, other):
+        raise TypeError(f"'<=' not supported between a Reactive and {other.__class__.__name__}, did you mean to use .value?")
+
+    def __gt__(self, other):
+        raise TypeError(f"'>' not supported between a Reactive and {other.__class__.__name__}, did you mean to use .value?")
+
+    def __ge__(self, other):
+        raise TypeError(f"'>=' not supported between a Reactive and {other.__class__.__name__}, did you mean to use .value?")
+
+    def __len__(self):
+        raise TypeError("'len(...)' is not supported for a Reactive, did you mean to use .value?")
+
     @property
     def lock(self):
         raise NotImplementedError
@@ -199,8 +236,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 +287,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 +305,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 +430,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, _SetValueNotSet
+
+    kernel_store = KernelStoreValue[StoreValue[S]](
+        StoreValue[S](private=default_value, public=_PublicValueNotSet(), get_traceback=None, set_value=_SetValueNotSet(), 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 +659,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 +690,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 +704,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)

solara/util.py

@@ -1,5 +1,6 @@
 import base64
 import contextlib
+import functools
 import gzip
 import hashlib
 import json
@@ -31,6 +32,28 @@ except RuntimeError:
     has_threads = False
 
 
+from reacton.utils import equals as equals_extra
+
+
+def equals_pickle(a, b):
+    """Compare two values for equality.
+
+    Avoid false negative, e.g. when comparing dataframes, we want to compare
+    the data, not the object identity.
+
+    """
+    if equals_extra(a, b):
+        return True
+    import pickle
+
+    try:
+        if pickle.dumps(a) == pickle.dumps(b):
+            return True
+    except Exception:
+        pass
+    return False
+
+
 def github_url(file):
     rel_path = os.path.relpath(file, Path(solara.__file__).parent.parent)
     github_url = solara.github_url + f"/blob/{solara.git_branch}/" + rel_path
@@ -306,3 +329,20 @@ def is_running_in_vscode():
 
 def is_running_in_voila():
     return os.environ.get("SERVER_SOFTWARE", "").startswith("voila")
+
+
+def once(f):
+    called = False
+    return_value = None
+
+    @functools.wraps(f)
+    def wrapper():
+        nonlocal called
+        nonlocal return_value
+        if called:
+            return return_value
+        called = True
+        return_value = f()
+        return return_value
+
+    return wrapper