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

solara/server/kernel_context.py

@@ -6,6 +6,8 @@ try:
 except ModuleNotFoundError:
     contextvars = None  # type: ignore
 
+import concurrent.futures
+import contextlib
 import dataclasses
 import enum
 import logging
@@ -24,7 +26,7 @@ from ipywidgets import DOMWidget, Widget
 import solara.server.settings
 import solara.util
 
-from . import kernel, kernel_context, websocket
+from . import kernel, websocket
 from .. import lifecycle
 from .kernel import Kernel, WebsocketStreamWrapper
 
@@ -33,7 +35,7 @@ logger = logging.getLogger("solara.server.app")
 
 
 class Local(threading.local):
-    kernel_context_stack: Optional[List[Optional["kernel_context.VirtualKernelContext"]]] = None
+    kernel_context_stack: Optional[List[Optional["VirtualKernelContext"]]] = None
 
 
 local = Local()
@@ -71,6 +73,7 @@ class VirtualKernelContext:
     page_status: Dict[str, PageStatus] = dataclasses.field(default_factory=dict)
     # only used for testing
     _last_kernel_cull_task: "Optional[asyncio.Future[None]]" = None
+    _last_kernel_cull_future: "Optional[concurrent.futures.Future[None]]" = None
     closed_event: threading.Event = dataclasses.field(default_factory=threading.Event)
     _on_close_callbacks: List[Callable[[], None]] = dataclasses.field(default_factory=list)
     lock: threading.RLock = dataclasses.field(default_factory=threading.RLock)
@@ -112,6 +115,10 @@ class VirtualKernelContext:
         with self, self.lock:
             for key in self.page_status:
                 self.page_status[key] = PageStatus.CLOSED
+            if self._last_kernel_cull_task:
+                self._last_kernel_cull_task.cancel()
+            if self._last_kernel_cull_future:
+                self._last_kernel_cull_future.cancel()
             if self.closed_event.is_set():
                 logger.error("Tried to close a kernel context that is already closed: %s", self.id)
                 return
@@ -129,9 +136,18 @@ class VirtualKernelContext:
             # what if we reference each other
             # import gc
             # gc.collect()
-            self.kernel.session.close()
+            self.kernel.close()
+            self.kernel = None  # type: ignore
             if self.id in contexts:
                 del contexts[self.id]
+            del current_context[get_current_thread_key()]
+            # We saw in memleak_test that there are sometimes other entries in current_context
+            # In which _DummyThread's reference this context, so we remove those references too
+            # TODO: Think about what to do with those Threads
+            _contexts = current_context.copy()
+            for key, _ctx in _contexts.items():
+                if _ctx is self:
+                    del current_context[key]
             self.closed_event.set()
 
     def _state_reset(self):
@@ -158,6 +174,8 @@ class VirtualKernelContext:
                 pickle.dump(state, f)
 
     def page_connect(self, page_id: str):
+        if self.closed_event.is_set():
+            raise RuntimeError("Cannot connect a page to a closed kernel")
         logger.info("Connect page %s for kernel %s", page_id, self.id)
         with self.lock:
             if self.closed_event.is_set():
@@ -184,13 +202,19 @@ class VirtualKernelContext:
                         logger.info("No connected pages, and timeout reached, shutting down virtual kernel %s", self.id)
                         self.close()
                 if current_event_loop is not None and future is not None:
-                    current_event_loop.call_soon_threadsafe(future.set_result, None)
+                    try:
+                        current_event_loop.call_soon_threadsafe(future.set_result, None)
+                    except RuntimeError:
+                        pass  # event loop already closed, happens during testing
             except asyncio.CancelledError:
                 if current_event_loop is not None and future is not None:
-                    if sys.version_info >= (3, 9):
-                        current_event_loop.call_soon_threadsafe(future.cancel, "cancelled because a new cull task was scheduled")
-                    else:
-                        current_event_loop.call_soon_threadsafe(future.cancel)
+                    try:
+                        if sys.version_info >= (3, 9):
+                            current_event_loop.call_soon_threadsafe(future.cancel, "cancelled because a new cull task was scheduled")
+                        else:
+                            current_event_loop.call_soon_threadsafe(future.cancel)
+                    except RuntimeError:
+                        pass  # event loop already closed, happens during testing
                 raise
 
         async def create_task():
@@ -212,7 +236,17 @@ class VirtualKernelContext:
                 self._last_kernel_cull_task.cancel()
 
             logger.info("Scheduling kernel cull for virtual kernel %s", self.id)
-            asyncio.run_coroutine_threadsafe(create_task(), keep_alive_event_loop)
+
+            async def create_task():
+                task = asyncio.create_task(kernel_cull())
+                # create a reference to the task so we can cancel it later
+                self._last_kernel_cull_task = task
+                try:
+                    await task
+                except RuntimeError:
+                    pass  # event loop already closed, happens during testing
+
+            self._last_kernel_cull_future = asyncio.run_coroutine_threadsafe(create_task(), keep_alive_event_loop)
             return future
 
     def page_disconnect(self, page_id: str) -> "Optional[asyncio.Future[None]]":
@@ -259,7 +293,12 @@ class VirtualKernelContext:
             pass
         else:
             future.set_result(None)
+
+        logger.info("page status: %s", self.page_status)
         with self.lock:
+            if self.closed_event.is_set():
+                logger.info("Kernel %s was already closed when page %s attempted to close", self.id, page_id)
+                return
             if self.page_status[page_id] == PageStatus.CLOSED:
                 logger.info("Page %s already closed for kernel %s", page_id, self.id)
                 return
@@ -351,6 +390,11 @@ def set_context_for_thread(context: VirtualKernelContext, thread: threading.Thre
     current_context[key] = context
 
 
+def clear_context_for_thread(thread: threading.Thread):
+    key = get_thread_key(thread)
+    current_context.pop(key, None)
+
+
 def has_current_context() -> bool:
     thread_key = get_current_thread_key()
     return (thread_key in current_context) and (current_context[thread_key] is not None)
@@ -377,6 +421,21 @@ def set_current_context(context: Optional[VirtualKernelContext]):
     current_context[thread_key] = context
 
 
+@contextlib.contextmanager
+def without_context():
+    context = None
+    try:
+        context = get_current_context()
+    except RuntimeError:
+        pass
+    thread_key = get_current_thread_key()
+    current_context[thread_key] = None
+    try:
+        yield
+    finally:
+        current_context[thread_key] = context
+
+
 def initialize_virtual_kernel(session_id: str, kernel_id: str, websocket: websocket.WebsocketWrapper):
     from solara.server import app as appmodule
 

solara/server/patch.py

@@ -1,4 +1,3 @@
-import functools
 import logging
 import os
 import pdb
@@ -15,6 +14,9 @@ import ipywidgets
 import ipywidgets.widgets.widget_output
 from IPython.core.interactiveshell import InteractiveShell
 
+import solara
+import solara.util
+
 from . import app, kernel_context, reload, settings
 from .utils import pdb_guard
 
@@ -39,6 +41,7 @@ class FakeIPython:
         # (although we don't really support it)
         self.events = mock.MagicMock()
         self.user_ns: Dict[Any, Any] = {}
+        self.custom_exceptions = ()
 
     def enable_gui(self, gui):
         logger.error("ignoring call to enable_gui(%s)", gui)
@@ -171,6 +174,8 @@ def display_solara(
 # if display_id:
 #     return DisplayHandle(display_id)
 
+get_ipython_original = IPython.get_ipython
+
 
 def get_ipython():
     if kernel_context.has_current_context():
@@ -178,7 +183,7 @@ def get_ipython():
         our_fake_ipython = FakeIPython(context)
         return our_fake_ipython
     else:
-        return None
+        return get_ipython_original()
 
 
 class context_dict(MutableMapping):
@@ -249,7 +254,8 @@ def auto_watch_get_template(get_template):
 
     def wrapper(abs_path):
         template = get_template(abs_path)
-        reload.reloader.watcher.add_file(abs_path)
+        with kernel_context.without_context():
+            reload.reloader.watcher.add_file(abs_path)
         return template
 
     return wrapper
@@ -272,10 +278,13 @@ def WidgetContextAwareThread__init__(self, *args, **kwargs):
         ThreadDebugInfo.created += 1
 
     self.current_context = None
-    try:
-        self.current_context = kernel_context.get_current_context()
-    except RuntimeError:
-        logger.debug(f"No context for thread {self}")
+    # if we do this for the dummy threads, we got into a recursion
+    # since threading.current_thread will call the _DummyThread constructor
+    if not ("name" in kwargs and "Dummy-" in kwargs["name"]):
+        try:
+            self.current_context = kernel_context.get_current_context()
+        except RuntimeError:
+            logger.debug(f"No context for thread {self._name}")
 
 
 def WidgetContextAwareThread__bootstrap(self):
@@ -291,6 +300,7 @@ def WidgetContextAwareThread__bootstrap(self):
 
 def _WidgetContextAwareThread__bootstrap(self):
     if not hasattr(self, "current_context"):
+        # this happens when a thread was running before we patched
         return Thread__bootstrap(self)
     if self.current_context:
         # we need to call this manually, because set_context_for_thread
@@ -299,15 +309,20 @@ def _WidgetContextAwareThread__bootstrap(self):
         if kernel_context.async_context_id is not None:
             kernel_context.async_context_id.set(self.current_context.id)
         kernel_context.set_context_for_thread(self.current_context, self)
-
         shell = self.current_context.kernel.shell
-        shell.display_pub.register_hook(shell.display_in_reacton_hook)
+        display_pub = shell.display_pub
+        display_in_reacton_hook = shell.display_in_reacton_hook
+        display_pub.register_hook(display_in_reacton_hook)
     try:
-        with pdb_guard():
+        context = self.current_context or solara.util.nullcontext()
+        with pdb_guard(), context:
             Thread__bootstrap(self)
     finally:
-        if self.current_context:
-            shell.display_pub.unregister_hook(shell.display_in_reacton_hook)
+        current_context = self.current_context
+        self.current_context = None
+        kernel_context.clear_context_for_thread(self)
+        if current_context:
+            display_pub.unregister_hook(display_in_reacton_hook)
 
 
 _patched = False
@@ -354,24 +369,7 @@ def patch_ipyreact():
     ipyreact.importmap._update_import_map = lambda: None
 
 
-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
-
-
-@once
+@solara.util.once
 def patch_matplotlib():
     import matplotlib
     import matplotlib._pylab_helpers

solara/server/server.py

@@ -16,6 +16,7 @@ import requests
 import solara
 import solara.routing
 import solara.settings
+import solara.server.settings
 from solara.lab import cookies as solara_cookies
 from solara.lab import headers as solara_headers
 
@@ -66,6 +67,8 @@ nbextensions_ignorelist = [
     "jupyter-js/extension",
     "jupyter-js-widgets/extension",
     "jupyter_dash/main",
+    "dash/main",
+    *solara.server.settings.server.ignore_nbextensions,
 ]
 
 
@@ -157,7 +160,8 @@ async def app_loop(
                     message = await ws.receive()
                 except websocket.WebSocketDisconnect:
                     try:
-                        context.kernel.session.websockets.remove(ws)
+                        if context.kernel is not None and context.kernel.session is not None:
+                            context.kernel.session.websockets.remove(ws)
                     except KeyError:
                         pass
                     logger.debug("Disconnected")
@@ -168,17 +172,22 @@ async def app_loop(
                 else:
                     msg = deserialize_binary_message(message)
                 t1 = time.time()
-                if not process_kernel_messages(kernel, msg):
-                    # if we shut down the kernel, we do not keep the page session alive
-                    context.close()
-                    return
+                # we don't want to have the kernel closed while we are processing a message
+                # therefore we use this mutex that is also used in the context.close method
+                with context.lock:
+                    if context.closed_event.is_set():
+                        return
+                    if not process_kernel_messages(kernel, msg):
+                        # if we shut down the kernel, we do not keep the page session alive
+                        context.close()
+                        return
                 t2 = time.time()
                 if settings.main.timing:
                     widgets_ids_after = set(patch.widgets)
                     created_widgets_count = len(widgets_ids_after - widgets_ids)
                     close_widgets_count = len(widgets_ids - widgets_ids_after)
                     print(  # noqa: T201
-                        f"timing: total={t2-t0:.3f}s, deserialize={t1-t0:.3f}s, kernel={t2-t1:.3f}s"
+                        f"timing: total={t2 - t0:.3f}s, deserialize={t1 - t0:.3f}s, kernel={t2 - t1:.3f}s"
                         f" widget: created: {created_widgets_count} closed: {close_widgets_count}"
                     )
     finally:
@@ -282,6 +291,7 @@ def read_root(
             return content
 
     default_app = app.apps["__default__"]
+    default_app.check()
     routes = default_app.routes
     router = solara.routing.Router(path, routes)
     if not router.possible_match:

solara/server/settings.py

@@ -132,6 +132,7 @@ OAUTH_TEST_CLIENT_IDs = [AUTH0_TEST_CLIENT_ID, FIEF_TEST_CLIENT_ID]
 
 class Session(BaseSettings):
     secret_key: str = SESSION_SECRET_KEY_DEFAULT
+    http_only: bool = False
     https_only: Optional[bool] = None
     same_site: str = "lax"
 
@@ -163,6 +164,15 @@ if is_mac_os_conda or is_wsl_windows:
     HOST_DEFAULT = "localhost"
 
 
+class Server(BaseSettings):
+    ignore_nbextensions: List[str] = []
+
+    class Config:
+        env_prefix = "solara_server_"
+        case_sensitive = False
+        env_file = ".env"
+
+
 class MainSettings(BaseSettings):
     use_pdb: bool = False
     mode: str = "production"
@@ -181,6 +191,7 @@ class MainSettings(BaseSettings):
 
 
 main = MainSettings()
+server = Server()
 theme = ThemeSettings()
 telemetry = Telemetry()
 ssg = SSG()

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
 
@@ -112,6 +113,7 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
         # we store a strong reference
         self.tasks: Set[asyncio.Task] = set()
         self.event_loop = asyncio.get_event_loop()
+        self._thread_id = threading.get_ident()
         if settings.main.experimental_performance:
             self.task = asyncio.ensure_future(self.process_messages_task())
 
@@ -121,37 +123,84 @@ 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
+            if isinstance(e, RuntimeError) and "close message" in repr(e):
+                raise websocket.WebSocketDisconnect() from e
+            else:
+                raise
+
+    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:
+            if isinstance(e, RuntimeError) and "close message" in repr(e):
+                raise websocket.WebSocketDisconnect() from e
+            else:
+                raise
 
     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
+                if self._thread_id == threading.get_ident():
+                    warnings.warn("""You are triggering a websocket send from the event loop thread.
+Support for this is experimental, and to avoid this message, make sure you trigger updates
+that trigger this from a different thread, e.g.:
+
+from anyio import to_thread
+await to_thread.run_sync(my_update)
+""")
+                    task = self.event_loop.create_task(self._send_text_exc(data))
+                    self.tasks.add(task)
+                    task.add_done_callback(self.tasks.discard)
+                else:
+                    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
+                if self._thread_id == threading.get_ident():
+                    warnings.warn("""You are triggering a websocket send from the event loop thread.
+Support for this is experimental, and to avoid this message, make sure you trigger updates
+that trigger this from a different thread, e.g.:
+
+from anyio import to_thread
+await to_thread.run_sync(my_update)
+""")
+                    task = self.event_loop.create_task(self._send_bytes_exc(data))
+                    self.tasks.add(task)
+                    task.add_done_callback(self.tasks.discard)
+
+                self.portal.call(self._send_bytes_exc, data)
 
     async def receive(self):
         if self.portal is None:
@@ -159,9 +208,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:
@@ -331,7 +380,7 @@ async def root(request: Request, fullpath: str = ""):
     forwarded_proto = request.headers.get("x-forwarded-proto")
     host = request.headers.get("host")
     if forwarded_proto and forwarded_proto != request.scope["scheme"]:
-        warnings.warn(f"""Header x-forwarded-proto={forwarded_proto!r} does not match scheme={request.scope['scheme']!r} as given by the asgi framework (probably uvicorn)
+        warnings.warn(f"""Header x-forwarded-proto={forwarded_proto!r} does not match scheme={request.scope["scheme"]!r} as given by the asgi framework (probably uvicorn)
 
 This might be a configuration mismatch behind a reverse proxy and can cause issues with redirect urls, and auth.
 
@@ -390,10 +439,10 @@ This could be a configuration mismatch behind a reverse proxy and can cause issu
 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}
+            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}
+            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
@@ -444,6 +493,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
@@ -452,8 +502,8 @@ See also https://solara.dev/documentation/getting_started/deploying/self-hosted
         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.
+        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.
 
@@ -469,6 +519,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 +600,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.42.0-py2.py3-none-any.whl", keep_going=True)
+    await micropip.install("/wheels/solara-1.44.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_"