solara-ui 1.31.0__py2.py3-none-any.whl

solara/server/settings.py

@@ -0,0 +1,215 @@
+import os
+import re
+import site
+import sys
+import uuid
+import warnings
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+try:
+    from filelock import FileLock
+except ModuleNotFoundError:
+    FileLock = None  # type: ignore
+
+import solara.util
+from solara.minisettings import BaseSettings
+
+from .. import (  # noqa  # sidefx is that this module creates the ~/.solara directory
+    settings,
+)
+from ..util import get_solara_home
+
+if site.getuserbase() and __file__.startswith(site.getuserbase()):
+    prefix = site.getuserbase()
+else:
+    prefix = sys.prefix
+
+
+class ThemeVariant(str, Enum):
+    light = "light"
+    dark = "dark"
+    auto = "auto"
+
+
+class ThemeSettings(BaseSettings):
+    variant: ThemeVariant = ThemeVariant.light
+    loader: str = "solara"
+
+    class Config:
+        env_prefix = "solara_theme_"
+        case_sensitive = False
+        env_file = ".env"
+
+
+class SSG(BaseSettings):
+    # the first app create will initialize this if it is not set
+    build_path: Optional[Path] = None
+    enabled: bool = False
+    headed: bool = False
+
+    class Config:
+        env_prefix = "solara_ssg_"
+        case_sensitive = False
+        env_file = ".env"
+
+
+class Search(BaseSettings):
+    enabled: bool = False
+
+    class Config:
+        env_prefix = "solara_search_"
+
+
+class Telemetry(BaseSettings):
+    mixpanel_token: str = "91845eb13a68e3db4e58d64ad23673b7"
+    mixpanel_enable: bool = True
+    server_user_id: str = "not_set"
+    server_fingerprint: str = str(uuid.getnode())
+    server_session_id: str = str(uuid.uuid4())
+
+    class Config:
+        env_prefix = "solara_telemetry_"
+        case_sensitive = False
+        env_file = ".env"
+
+
+class Assets(BaseSettings):
+    proxy_cache_dir: Path = Path(prefix + "/share/solara/cdn/")
+    fontawesome_enabled: bool = True
+    fontawesome_path: str = "/font-awesome@4.5.0/css/font-awesome.min.css"
+
+    class Config:
+        env_prefix = "solara_assets_"
+        case_sensitive = False
+        env_file = ".env"
+
+
+class Kernel(BaseSettings):
+    cull_timeout: str = "24h"
+    max_count: Optional[int] = None
+    threaded: bool = solara.util.has_threads
+
+    class Config:
+        env_prefix = "solara_kernel_"
+        case_sensitive = False
+        env_file = ".env"
+
+
+AUTH0_TEST_CLIENT_ID = "cW7owP5Q52YHMZAnJwT8FPlH2ZKvvL3U"
+AUTH0_TEST_CLIENT_SECRET = "zxITXxoz54OjuSmdn-PluQgAwbeYyoB7ALlnLoodftvAn81usDXW0quchvoNvUYD"
+AUTH0_TEST_API_BASE_URL = "dev-y02f2bpr8skxu785.us.auth0.com"
+AUTH0_LOGOUT_PATH = "v2/logout"
+
+FIEF_TEST_CLIENT_ID = "x2np62qgwp6hnEGTP4JYUE3igdZWhT-AvjpjwwDyKXU"
+FIEF_TEST_CLIENT_SECRET = "XQlByE1pVIz5h2SBN2GYDwT_ziqArHJgLD3KqMlCHjg"
+FIEF_TEST_API_BASE_URL = "solara-dev.fief.dev"
+FIEF_LOGOUT_PATH = "logout"
+SESSION_SECRET_KEY_DEFAULT = "change me"
+
+OAUTH_TEST_CLIENT_IDs = [AUTH0_TEST_CLIENT_ID, FIEF_TEST_CLIENT_ID]
+
+
+class Session(BaseSettings):
+    secret_key: str = SESSION_SECRET_KEY_DEFAULT
+    https_only: Optional[bool] = None
+    same_site: str = "lax"
+
+    class Config:
+        env_prefix = "solara_session_"
+        case_sensitive = False
+        env_file = ".env"
+
+
+class OAuth(BaseSettings):
+    private: bool = False
+
+    client_id: str = AUTH0_TEST_CLIENT_ID
+    client_secret: str = AUTH0_TEST_CLIENT_SECRET
+    api_base_url: str = AUTH0_TEST_API_BASE_URL
+    logout_path: str = AUTH0_LOGOUT_PATH
+    scope: str = "openid profile email"
+
+    class Config:
+        env_prefix = "solara_oauth_"
+        case_sensitive = False
+        env_file = ".env"
+
+
+HOST_DEFAULT = os.environ.get("HOST", "localhost")
+is_mac_os_conda = "arm64-apple-darwin" in HOST_DEFAULT
+is_wsl_windows = re.match(r".*?-w1[0-9]", HOST_DEFAULT)
+if is_mac_os_conda or is_wsl_windows:
+    HOST_DEFAULT = "localhost"
+
+
+class MainSettings(BaseSettings):
+    use_pdb: bool = False
+    mode: str = "production"
+    tracer: bool = False
+    timing: bool = False
+    root_path: Optional[str] = None  # e.g. /myapp (without trailing slash)
+    base_url: str = ""  # e.g. https://myapp.solara.run/myapp/
+    platform: str = sys.platform
+    host: str = HOST_DEFAULT
+    experimental_performance: bool = False
+
+    class Config:
+        env_prefix = "solara_"
+        case_sensitive = False
+        env_file = ".env"
+
+
+main = MainSettings()
+theme = ThemeSettings()
+telemetry = Telemetry()
+ssg = SSG()
+search = Search()
+assets = Assets()
+oauth = OAuth()
+session = Session()
+kernel = Kernel()
+# fail early
+solara.util.parse_timedelta(kernel.cull_timeout)
+
+if settings.assets.proxy:
+    try:
+        assets.proxy_cache_dir.mkdir(exist_ok=True, parents=True)
+    except OSError as e:
+        settings.assets.proxy = False
+        warnings.warn(
+            f"Could not create {assets.proxy_cache_dir} due to {e}. We will automatically disable the assets proxy for you. "
+            "If you want to disable this warning, set SOLARA_ASSETS_PROXY to False (e.g. export SOLARA_ASSETS_PROXY=false). "
+            "Or change the SOLARA_PROXY_CACHE_DIR environment variable to a directory where you have write access."
+        )
+        # that's ok, the user probably doesn't have permission to create the directory
+        # in this case, we would need to install solara-assets?
+        pass
+
+if telemetry.server_user_id == "not_set" and FileLock is not None:
+    home = get_solara_home()
+    server_user_id_file = home / "server_user_id.txt"
+    try:
+        with FileLock(str(server_user_id_file) + ".lock"):
+            if not server_user_id_file.exists():
+                server_user_id_file.write_text(str(uuid.uuid4()))
+            telemetry.server_user_id = server_user_id_file.read_text()
+    except OSError:
+        pass  # it's ok
+
+if oauth.client_id:
+    if oauth.client_id not in OAUTH_TEST_CLIENT_IDs:
+        if session.secret_key == SESSION_SECRET_KEY_DEFAULT:
+            raise ValueError(
+                "You must set a session secret key for oauth, it is not safe to use the default. Please set SOLARA_SESSION_SECRET_KEY in your environment."
+            )
+        if session.https_only is None:
+            raise ValueError(
+                "You must set https_only for the session to True (recommended) or False in your are using your own oauth provider."
+                "Please set SOLARA_SESSION_HTTPS_ONLY in your environment to True or False"
+            )
+    else:
+        # for the test accounts, this is fine
+        if session.https_only is None:
+            session.https_only = False

solara/server/shell.py

@@ -0,0 +1,251 @@
+import io
+import sys
+from binascii import b2a_base64
+from threading import local
+from unittest.mock import Mock
+
+import reacton.patch_display
+from IPython.core.displaypub import DisplayPublisher
+from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
+from jupyter_client.session import Session, extract_header
+from traitlets import Any, CBytes, Dict, Instance, Type, default
+
+
+def encode_images(obj):
+    # no-op in ipykernel
+    return obj
+
+
+def json_clean(obj):
+    # no-op in ipykernel
+    return obj
+
+
+# based on the zmq display publisher from ipykernel
+# ideally this goes out of ipykernel
+class SolaraDisplayPublisher(DisplayPublisher):
+    """A display publisher that publishes data using a ZeroMQ PUB socket."""
+
+    session = Instance(Session, allow_none=True)
+    pub_socket = Any(allow_none=True)
+    parent_header = Dict({})
+    topic = CBytes(b"display_data")
+
+    _thread_local = Any()
+
+    def set_parent(self, parent):
+        """Set the parent for outbound messages."""
+        self.parent_header = extract_header(parent)
+
+    def _flush_streams(self):
+        """flush IO Streams prior to display"""
+        sys.stdout.flush()
+        sys.stderr.flush()
+
+    @default("_thread_local")
+    def _default_thread_local(self):
+        """Initialize our thread local storage"""
+        return local()
+
+    @property
+    def _hooks(self):
+        if not hasattr(self._thread_local, "hooks"):
+            # create new list for a new thread
+            self._thread_local.hooks = []
+        return self._thread_local.hooks
+
+    def publish(
+        self,
+        data,
+        metadata=None,
+        transient=None,
+        update=False,
+    ):
+        """Publish a display-data message
+
+        Parameters
+        ----------
+        data : dict
+            A mime-bundle dict, keyed by mime-type.
+        metadata : dict, optional
+            Metadata associated with the data.
+        transient : dict, optional, keyword-only
+            Transient data that may only be relevant during a live display,
+            such as display_id.
+            Transient data should not be persisted to documents.
+        update : bool, optional, keyword-only
+            If True, send an update_display_data message instead of display_data.
+        """
+        self._flush_streams()
+        if metadata is None:
+            metadata = {}
+        if transient is None:
+            transient = {}
+        self._validate_data(data, metadata)
+        content = {}
+        content["data"] = encode_images(data)
+        content["metadata"] = metadata
+        content["transient"] = transient
+
+        msg_type = "update_display_data" if update else "display_data"
+
+        # Use 2-stage process to send a message,
+        # in order to put it through the transform
+        # hooks before potentially sending.
+        assert self.session is not None
+        msg = self.session.msg(msg_type, json_clean(content), parent=self.parent_header)
+
+        # Each transform either returns a new
+        # message or None. If None is returned,
+        # the message has been 'used' and we return.
+        for hook in self._hooks:
+            msg = hook(msg)
+            if msg is None:
+                return
+
+        self.session.send(
+            self.pub_socket,
+            msg,
+            ident=self.topic,
+        )
+
+    def clear_output(self, wait=False):
+        """Clear output associated with the current execution (cell).
+
+        Parameters
+        ----------
+        wait : bool (default: False)
+            If True, the output will not be cleared immediately,
+            instead waiting for the next display before clearing.
+            This reduces bounce during repeated clear & display loops.
+
+        """
+        assert self.session is not None
+        content = dict(wait=wait)
+        self._flush_streams()
+        msg = self.session.msg("clear_output", json_clean(content), parent=self.parent_header)
+        for hook in self._hooks:
+            msg = hook(msg)
+            if msg is None:
+                return
+
+        self.session.send(
+            self.pub_socket,
+            msg,
+            ident=self.topic,
+        )
+
+    def register_hook(self, hook):
+        """
+        Registers a hook with the thread-local storage.
+
+        Parameters
+        ----------
+        hook : Any callable object
+
+        Returns
+        -------
+        Either a publishable message, or `None`.
+        The DisplayHook objects must return a message from
+        the __call__ method if they still require the
+        `session.send` method to be called after transformation.
+        Returning `None` will halt that execution path, and
+        session.send will not be called.
+        """
+        self._hooks.append(hook)
+
+    def unregister_hook(self, hook):
+        """
+        Un-registers a hook with the thread-local storage.
+
+        Parameters
+        ----------
+        hook : Any callable object which has previously been
+            registered as a hook.
+
+        Returns
+        -------
+        bool - `True` if the hook was removed, `False` if it wasn't
+            found.
+        """
+        try:
+            self._hooks.remove(hook)
+            return True
+        except ValueError:
+            return False
+
+
+class SolaraInteractiveShell(InteractiveShell):
+    display_pub_class = Type(SolaraDisplayPublisher)
+    history_manager = Any()  # type: ignore
+    display_pub: SolaraDisplayPublisher
+
+    def set_parent(self, parent):
+        """Tell the children about the parent message."""
+        self.display_pub.set_parent(parent)
+
+    def init_history(self):
+        self.history_manager = Mock()  # type: ignore
+
+    def init_display_formatter(self):
+        super().init_display_formatter()
+        assert self.display_formatter is not None
+        self.display_formatter.ipython_display_formatter = reacton.patch_display.ReactonDisplayFormatter()
+
+        # matplotlib support for display(figure)
+        # IPython.core.pylabtools has support for this, but it requires importing matplotlib
+        # which would slow down startup, so we do it here using for_type using a string as argument.
+        def encode_png(figure, **kwargs):
+            f = io.BytesIO()
+            format = "png"
+            figure.savefig(f, format=format, **kwargs)
+            bytes_data = f.getvalue()
+            base64_data = b2a_base64(bytes_data, newline=False).decode("ascii")
+            return base64_data
+
+        formatter = self.display_formatter.formatters["image/png"]
+        formatter.for_type("matplotlib.figure.Figure", encode_png)
+
+    def init_display_pub(self):
+        super().init_display_pub()
+        self.display_pub.register_hook(self.display_in_reacton_hook)
+
+    def display_in_reacton_hook(self, msg):
+        """Will intercept a display call and add the display data to an output widget when in a reacton context/render function."""
+        # similar to reacton.patch_display.publish
+        from reacton.core import get_render_context
+
+        rc = get_render_context(required=False)
+        # only during the render phase we want to capture the display calls
+        # during the reconsolidation phase we want to let the original display publisher do its thing
+        # such as adding it to a output widget
+        if rc is not None and not rc.reconsolidating and msg["msg_type"] == "display_data":
+            from reacton.ipywidgets import Output
+
+            Output(
+                outputs=[
+                    {
+                        "output_type": "display_data",
+                        "data": msg["content"]["data"],
+                        "metadata": msg["content"]["metadata"],
+                    }
+                ]
+            )
+            return None  # do not send to the frontend
+        return msg
+
+    def reset(self, new_session=True, aggressive=False):
+        # if we dont override this with a dummy, the unittests will take a long time
+        # to exit. Hitting ctrl-c showed the following stacktrace:
+        # Traceback (most recent call last):
+        # File "/Users/maartenbreddels/miniconda3/envs/dev/lib/python3.9/site-packages/IPython/core/interactiveshell.py", line 3924, in atexit_operations
+        #     self.reset(new_session=False)
+        # File "/Users/maartenbreddels/miniconda3/envs/dev/lib/python3.9/site-packages/IPython/core/interactiveshell.py", line 1456, in reset
+        #     self.displayhook.flush()
+        # File "/Users/maartenbreddels/miniconda3/envs/dev/lib/python3.9/site-packages/IPython/core/displayhook.py", line 311, in flush
+        #     gc.collect()
+        # So this dummy will prevent that.
+        pass
+
+
+InteractiveShellABC.register(SolaraInteractiveShell)