solara 1.30.0__py2.py3-none-any.whl → 1.31.0__py2.py3-none-any.whl

solara/scope/__init__.py

@@ -1,87 +0,0 @@
-import re
-import sys
-import threading
-from typing import MutableMapping
-
-from .types import ObservableMutableMapping
-
-
-def _in_solara_server():
-    return "solara.server" in sys.modules
-
-
-class ConnectionScope(ObservableMutableMapping):
-    def __init__(self, name="connection"):
-        super().__init__()
-        self._global_dict = {}
-        self.name = name
-        self.lock = threading.Lock()
-
-    def _get_dict(self) -> MutableMapping:
-        if _in_solara_server():
-            import solara.server.kernel_context
-
-            context = solara.server.kernel_context.get_current_context()
-            if self.name not in context.user_dicts:
-                with self.lock:
-                    if self.name not in context.user_dicts:
-                        context.user_dicts[self.name] = {}
-            return context.user_dicts[self.name]
-        else:
-            return self._global_dict
-
-
-class ObservableDict(ObservableMutableMapping):
-    def __init__(self):
-        super().__init__()
-        self._global_dict = {}
-
-    def _get_dict(self) -> MutableMapping:
-        return self._global_dict
-
-
-worker = ObservableDict()
-connection = ConnectionScope()
-
-
-def get_kernel_id(ipython_fallback=True) -> str:
-    """Returns the kernel id, a unique string for each virtual kernel.
-
-    See [Understanding solara server](/docs/understanding/solara-server) for understanding the concept of virtual kernels
-    and their lifetime.
-
-    This unique ID can be useful to to implement storing state, scoped to a kernel. See [the scope example](/examples/general/scopes) for an example.
-
-    If `ipython_fallback` is `True` (default), this function will also work in IPython notebooks, where it will return the IPython kernel id.
-
-    """
-    import solara.server.kernel_context
-
-    try:
-        context = solara.server.kernel_context.get_current_context()
-    except RuntimeError as e:
-        if not ipython_fallback:
-            raise
-        import IPython
-
-        ipython = IPython.get_ipython()
-        if not ipython or not hasattr(ipython, "kernel"):
-            raise RuntimeError("Not in a kernel") from e
-        kernel = ipython.kernel
-        regex = r"[\\/]kernel-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.json$"
-        connection_file = kernel.config["IPKernelApp"]["connection_file"]
-        return re.compile(regex).search(connection_file).group(1)  # type: ignore
-    return context.id
-
-
-def get_session_id() -> str:
-    """Returns the session id, which is stored using a browser cookie.
-
-    See [Understanding solara server](/docs/understanding/solara-server#session) for more information about the Solara sessions.
-
-    This unique ID can be useful to to implement storing state, scoped to a browser session. See [the scope example](/examples/general/scopes) for an example.
-    """
-    import solara.server.kernel_context
-
-    context = solara.server.kernel_context.get_current_context()
-    return context.session_id

solara/scope/types.py

@@ -1,55 +0,0 @@
-import threading
-from abc import abstractmethod
-from typing import Any, Callable, Dict, List, MutableMapping
-from warnings import warn
-
-ObserverCallback = Callable[[Any, Any], None]
-
-
-class MutableMappingBase(MutableMapping):
-    @abstractmethod
-    def _get_dict(self) -> MutableMapping:
-        pass
-
-    def __delitem__(self, key) -> None:
-        self._get_dict().__delitem__(key)
-
-    def __getitem__(self, key):
-        return self._get_dict().__getitem__(key)
-
-    def __iter__(self):
-        return self._get_dict().__iter__()
-
-    def __len__(self):
-        return self._get_dict().__len__()
-
-    def __setitem__(self, key, value):
-        self._get_dict().__setitem__(key, value)
-
-
-class ObservableMutableMapping(MutableMappingBase):
-    # list of observers for each key
-    observers: Dict[Any, List[ObserverCallback]]
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.observers = {}
-        self.lock = threading.Lock()
-
-    def subscribe_key(self, key, callback: ObserverCallback):
-        if key not in self.observers:
-            with self.lock:
-                if key not in self.observers:
-                    self.observers[key] = []
-        self.observers[key].append(callback)
-        if self.observers[key].count(callback) > 1:
-            warn("Callback already subscribed")
-
-        def unsubscribe():
-            self.observers[key].remove(callback)
-
-        return unsubscribe
-
-    def trigger_key(self, key):
-        for callback in self.observers[key]:
-            callback(key, self[key])

solara/server/app.py

@@ -1,490 +0,0 @@
-import dataclasses
-import importlib.util
-import logging
-import os
-import pickle
-import sys
-import threading
-import traceback
-import warnings
-from enum import Enum
-from pathlib import Path
-from typing import Any, Dict, List, Optional, cast
-
-import ipywidgets as widgets
-import reacton
-from reacton.core import Element, render
-
-import solara
-from solara.util import nested_get
-
-from . import kernel_context, patch, reload, settings
-from .kernel import Kernel
-from .utils import pdb_guard
-
-WebSocket = Any
-apps: Dict[str, "AppScript"] = {}
-thread_lock = threading.Lock()
-
-logger = logging.getLogger("solara.server.app")
-
-reload.reloader.start()
-
-
-class AppType(str, Enum):
-    SCRIPT = "script"
-    NOTEBOOK = "notebook"
-    MODULE = "module"
-    DIRECTORY = "directory"
-
-
-def display(*args, **kwargs):
-    print("display not implemented", args, kwargs)  # noqa
-
-
-class AppScript:
-    directory: Path
-    routes: List[solara.Route]
-
-    def __init__(self, name, default_app_name="Page"):
-        self.fullname = name
-        if reload.reloader.on_change:
-            raise RuntimeError("Previous reloader still had a on_change attached, no cleanup?")
-        reload.reloader.on_change = self.on_file_change
-
-        self.app_name = default_app_name
-        if ":" in self.fullname:
-            self.name, self.app_name = self.fullname.rsplit(":", 1)
-            if len(self.name) == 1:  # a windows drive letter, restore
-                self.name = self.fullname
-                self.app_name = default_app_name
-        else:
-            self.name = name
-        self.path: Path = Path(self.name).resolve()
-        try:
-            context = kernel_context.get_current_context()
-        except RuntimeError:
-            context = None
-        if context is not None:
-            raise RuntimeError(f"We should not have an existing Solara app context when running an app for the first time: {context}")
-        dummy_kernel_context = kernel_context.create_dummy_context()
-        with dummy_kernel_context:
-            app = self._execute()
-
-        # We now ran the app, now we can check for patches that require heavy imports
-        patch.patch_heavy_imports()
-
-        self._first_execute_app = app
-        reload.reloader.root_path = self.directory
-        if self.type == AppType.MODULE:
-            package_name = self.name.split(".")[0]
-            mod = importlib.import_module(package_name)
-            if mod.__file__ is not None:
-                package_root_path = Path(mod.__file__).parent
-                reload.reloader.root_path = package_root_path
-        dummy_kernel_context.close()
-
-    def _execute(self):
-        logger.info("Executing %s", self.name)
-        app = None
-        routes: Optional[List[solara.Route]] = None
-
-        def add_path():
-            # this is not expected for modules, similar to `python script.py and python -m package.mymodule`
-            if self.type in [AppType.SCRIPT, AppType.NOTEBOOK]:
-                working_directory = str(self.path.parent)
-                if working_directory not in sys.path:
-                    sys.path.insert(0, working_directory)
-
-        if self.path.is_dir():
-            self.type = AppType.DIRECTORY
-            # resolve the directory, because Path("file").parent.parent == "." != ".."
-            self.directory = self.path.resolve()
-            routes = solara.generate_routes_directory(self.path)
-
-            if any(name for name in sys.modules.keys() if name.startswith(self.name)):
-                logger.warn(
-                    f"Directory {self.name} is also used as a package. This can cause modules to be loaded twice, and might "
-                    "cause unexpected behavior. If you run solara from a different directory (e.g. the parent directory) you "
-                    "can avoid this ambiguity."
-                )
-
-        elif self.name.endswith(".py"):
-            self.type = AppType.SCRIPT
-            add_path()
-            # manually add the script to the watcher
-            reload.reloader.watcher.add_file(self.path)
-            self.directory = self.path.parent.resolve()
-            initial_namespace = {
-                "__name__": "__main__",
-            }
-            with reload.reloader.watch():
-                routes = [solara.autorouting._generate_route_path(self.path, first=True, initial_namespace=initial_namespace)]
-        elif self.name.endswith(".ipynb"):
-            self.type = AppType.NOTEBOOK
-            add_path()
-            # manually add the notebook to the watcher
-            reload.reloader.watcher.add_file(self.path)
-            self.directory = self.path.parent.resolve()
-            with reload.reloader.watch():
-                routes = [solara.autorouting._generate_route_path(self.path, first=True)]
-        else:
-            # the module itself will be added by reloader
-            # automatically
-            with reload.reloader.watch():
-                self.type = AppType.MODULE
-                try:
-                    spec = importlib.util.find_spec(self.name)
-                except ValueError:
-                    if self.name not in sys.modules:
-                        raise ImportError(f"Module {self.name} not found")
-                    spec = importlib.util.spec_from_file_location(self.name, sys.modules[self.name].__file__)
-                if spec is None:
-                    raise ImportError(f"Module {self.name} cannot be found")
-                assert spec is not None
-                if spec.origin is None:
-                    raise ImportError(f"Module {self.name} cannot be found, or is a namespace package")
-                assert spec.origin is not None
-                self.path = Path(spec.origin)
-                self.directory = self.path.parent
-
-                mod = importlib.import_module(self.name)
-                routes = solara.generate_routes(mod)
-
-        app = solara.autorouting.RenderPage(self.app_name)
-
-        # when the root moduled defined routes, skip the enclosing route object
-        if len(routes) == 1 and routes[0].module and hasattr(routes[0].module, "routes"):
-            if routes[0].component:
-                warnings.warn(
-                    f"{self.name} has a component defined, but you are also defining routes."
-                    " To avoid confusing, consider renaming the {self.app_name} component."
-                )
-            routes = routes[0].children
-
-        if self.app_name != "Page":
-            # if we specified the app name, we replace the component
-            if len(routes) > 1:
-                raise ValueError(f"App {self.name} has multiple routes, but a default app name was given: {self.app_name}")
-            assert len(routes) == 1
-            component = nested_get(routes[0].module.__dict__, self.app_name, None)
-            routes = [dataclasses.replace(routes[0], component=component)]
-
-        if settings.ssg.build_path is None:
-            settings.ssg.build_path = self.directory.parent.resolve() / "build"
-
-        # auto enable search if search.json exists
-        search_index_file = self.directory.parent / "assets" / "search.json"
-        if search_index_file.exists():
-            settings.search.enabled = True
-
-        # this might be useful for development
-        # but requires reloading of react in solara itself
-        # for name, module in sys.modules.items():
-        #     if name.startswith("reacton"):
-        #         file = inspect.getfile(module)
-        #         self.watcher.add_file(file)
-
-        # cgi vars: https://datatracker.ietf.org/doc/html/rfc3875
-        # we cannot set script name, because gunicorn uses it (and will crash)
-        # os.environ["SCRIPT_NAME"] = self.name
-        os.environ["PATH_TRANSLATED"] = str(self.path.resolve())
-
-        self.routes = routes
-
-        # this might be useful for development
-        # but requires reloading of react in solara itself
-        # for name, module in sys.modules.items():
-        #     if name.startswith("reacton"):
-        #         file = inspect.getfile(module)
-        #         self.watcher.add_file(file)
-
-        # cgi vars: https://datatracker.ietf.org/doc/html/rfc3875
-        # we cannot set script name, because gunicorn uses it (and will crash)
-        # os.environ["SCRIPT_NAME"] = self.name
-        os.environ["PATH_TRANSLATED"] = str(self.path.resolve())
-        return app
-
-    def close(self):
-        reload.reloader.on_change = None
-        context_values = list(kernel_context.contexts.values())
-        kernel_context.contexts.clear()
-        for context in context_values:
-            context.close()
-
-    def run(self):
-        if reload.reloader.requires_reload or self._first_execute_app is None:
-            with thread_lock:
-                if reload.reloader.requires_reload or self._first_execute_app is None:
-                    self._first_execute_app = None
-                    self._first_execute_app = self._execute()
-                    print("Re-executed app", self.name)  # noqa
-                    # We now ran the app again, might contain new imports
-                    patch.patch_heavy_imports()
-
-        return self._first_execute_app
-
-    def on_file_change(self, name):
-        path = Path(name)
-        if path.suffix == ".vue":
-            logger.info("Vue file changed: %s", name)
-            template_content = path.read_text()
-            for context in list(kernel_context.contexts.values()):
-                with context:
-                    for filepath, widget in context.templates.items():
-                        if filepath == str(path):
-                            widget.template = template_content
-        else:
-            logger.info("Reload requires due to change in module: %s", name)
-            self.reload()
-
-    def reload(self):
-        # if multiple files change in a short time, we want to do this
-        # not concurrently. Even better would be to do a debounce?
-        with thread_lock:
-            # TODO: clearing the type_counter is a bit of a hack
-            # and we should introduce reload 'hooks', so there is
-            # less interdependency between modules
-            import solara.lab.toestand
-
-            solara.lab.toestand.ConnectionStore._type_counter.clear()
-
-            # we need to remove callbacks that are added in the app code
-            # which will be re-executed after the reload and we do not
-            # want to keep executing the old ones.
-            for kc in kernel_context._on_kernel_start_callbacks.copy():
-                callback, path, module, cleanup = kc
-                will_reload = False
-                if module is not None:
-                    module_name = module.__name__
-                    if module_name in reload.reloader.get_reload_module_names():
-                        will_reload = True
-                elif path is not None:
-                    if str(path.resolve()).startswith(str(self.directory)):
-                        will_reload = True
-                    else:
-                        logger.warning(
-                            "script %s is not in the same directory as the app %s but is using on_kernel_start, "
-                            "this might lead to multiple entries, and might indicate a bug.",
-                            path,
-                            self.directory,
-                        )
-
-                if will_reload:
-                    logger.info("reload: Removing on_kernel_start callback: %s (since it will be added when reloaded)", callback)
-                    cleanup()
-
-            context_values = list(kernel_context.contexts.values())
-            # save states into the context so the hot reload will
-            # keep the same state
-            for context in context_values:
-                render_context = cast(reacton.core._RenderContext, context.app_object)
-                if render_context:
-                    with context:
-                        # we save the state for when the app reruns, so we stay in the same state.
-                        # (e.g. button clicks, chosen options etc)
-                        # for instance a dataframe, needs to be pickled, because after the pandas
-                        # module is reloaded, it's a different class type
-                        logger.info("pickling state: %s", render_context.state_get())
-                        try:
-                            context.state = pickle.dumps(render_context.state_get())
-                        except Exception as e:
-                            logger.warning("Could not pickle state, next render the state will be lost: %s", e)
-                        # clear/cleanup the render_context, so during reload we start
-                        # from scratch
-                        context.app_object = None
-                        # we want to reuse the container
-                        render_context.container = None
-                        try:
-                            render_context.close()
-                        except Exception as e:
-                            logger.exception("Could not close render context: %s", e)
-
-            # ask all contexts/users to reload
-            for context in context_values:
-                with context:
-                    context.reload()
-
-
-def _run_app(
-    app_state,
-    app_script: AppScript,
-    pathname: str,
-    render_context: reacton.core._RenderContext = None,
-):
-    # app.signal_hook_install()
-    main_object = app_script.run()
-    app_state = pickle.loads(app_state) if app_state is not None else None
-    if app_state:
-        logger.info("Restoring state: %r", app_state)
-
-    context = kernel_context.get_current_context()
-    container = context.container
-    if isinstance(main_object, widgets.Widget):
-        return main_object, render_context
-    elif isinstance(main_object, Element) or isinstance(main_object, reacton.core.Component):
-        if isinstance(main_object, Element):
-            children = [main_object]
-        else:
-            children = [main_object()]
-        solara_context = solara.RoutingProvider(children=children, routes=app_script.routes, pathname=pathname)
-        if render_context is None:
-            result = render(solara_context, container, handle_error=True, initial_state=app_state)
-            # support older versions of react
-            if isinstance(result, tuple):
-                container, render_context = result
-            else:
-                render_context = result
-        else:
-            if app_state:
-                render_context.state_set(render_context.context_root, app_state)
-            result = render_context.render(solara_context)
-            container = render_context.container
-        # return container, render_context
-    else:
-        extra = ""
-        dotted = []
-        for key, value in vars(main_object).items():
-            if isinstance(value, (Element, widgets.Widget)):
-                dotted.append(f"{app_script.app_name}.{key}")
-        if dotted:
-            extra = " We did find that sub objects that might work: " + ", ".join(dotted)
-        raise ValueError(
-            f"Main object (with name {app_script.app_name} in {app_script.path}) is not a Widget, Element or Component, but {type(main_object)}." + extra
-        )
-    return container, render_context
-
-
-def load_app_widget(app_state, app_script: AppScript, pathname: str):
-    # load the app, and set it at the child of the context's container
-    app_state_initial = app_state
-    context = kernel_context.get_current_context()
-    container = context.container
-    assert container is not None
-    try:
-        import ipyreact
-
-        del ipyreact
-    except ModuleNotFoundError:
-        pass
-    else:
-        import solara.server.esm
-
-        # will create widgets, but will clean itself up when the kernel closes
-        solara.server.esm.create_modules()
-        solara.server.esm.create_import_map()
-
-    try:
-        render_context = context.app_object
-        app_state = app_state_initial
-        with pdb_guard():
-            widget, render_context = _run_app(
-                app_state,
-                app_script,
-                pathname,
-                render_context=render_context,
-            )
-            if render_context is None:
-                assert context.container is not None
-                context.container.children = [widget]
-
-        if render_context:
-            context.app_object = render_context
-
-    except BaseException as e:
-        error = ""
-        error = "".join(traceback.format_exception(None, e, e.__traceback__))
-        print(error, file=sys.stdout, flush=True)  # noqa
-        # widget = widgets.Label(value="Error, see server logs")
-        import html
-
-        error = html.escape(error)
-        with context:
-            widget = widgets.HTML(f"<pre>{error}</pre>", layout=widgets.Layout(overflow="auto"))
-            container.children = [widget]
-
-
-def load_themes(themes: Dict[str, Dict[str, str]], dark: bool):
-    # While these usually gets set from the frontend, in solara (server) we want to know theme information directly at the first
-    # render. Also, using the same trait allows us to write code which works on all widgets platforms, instead
-    # or using something different when running under solara server
-    from solara.lab.components.theming import _set_theme, theme
-
-    _set_theme(themes)
-    theme.dark_effective = dark
-
-
-def solara_comm_target(comm, msg_first):
-    app: Optional[AppScript] = None
-
-    def on_msg(msg):
-        nonlocal app
-        data = msg["content"]["data"]
-        method = data["method"]
-        if method == "run":
-            args = data["args"]
-            path = args.get("path", "")
-            app_name = args.get("appName") or "__default__"
-            app = apps[app_name]
-            context = kernel_context.get_current_context()
-            import ipyvuetify
-
-            container = ipyvuetify.Html(tag="div")
-            context.container = container
-            themes = args.get("themes")
-            dark = args.get("dark")
-            load_themes(themes, dark)
-            load_app_widget(None, app, path)
-            comm.send({"method": "finished", "widget_id": context.container._model_id})
-        elif method == "app-status":
-            context = kernel_context.get_current_context()
-            # if there is no container, we never ran the app
-            if context.container is not None:
-                logger.info("app-status check: %s app started", context.id)
-                comm.send({"method": "app-status", "started": True})
-            else:
-                logger.info("app-status check: %s app not started", context.id)
-                comm.send({"method": "app-status", "started": False})
-
-        elif method == "reload":
-            from solara.lab.components.theming import _get_theme, theme
-
-            assert app is not None
-            context = kernel_context.get_current_context()
-            path = data.get("path", "")
-            current_theme = theme._instance.value
-            theme_dict = _get_theme(current_theme)
-
-            with context:
-                context.restart()
-                load_themes(theme_dict, current_theme.dark_effective)
-                load_app_widget(context.state, app, path)
-                comm.send({"method": "finished"})
-        else:
-            logger.error("Unknown comm method called on solara.control comm: %s", method)
-
-    comm.on_msg(on_msg)
-
-    def reload():
-        # we don't reload the app ourself, we send a message to the client
-        # this ensures that we don't run code of any client that for some reason is connected
-        # but not working anymore. And it indirectly passes a message from the current thread
-        # (which is that of the Reloader/watchdog), to the thread of the client
-        logger.debug(f"Send reload to client: {context.id}")
-        comm.send({"method": "reload"})
-
-    context = kernel_context.get_current_context()
-    context.reload = reload
-
-
-def register_solara_comm_target(kernel: Kernel):
-    kernel.comm_manager.register_target("solara.control", solara_comm_target)
-
-
-from . import patch  # noqa
-
-patch.patch()
-# the default app (used in solara-server)
-if "SOLARA_APP" in os.environ:
-    with pdb_guard():
-        apps["__default__"] = AppScript(os.environ.get("SOLARA_APP", "solara.website.pages:Page"))

solara/server/assets/custom.css

@@ -1 +0,0 @@
-/* not empty *

solara/server/assets/custom.js

@@ -1 +0,0 @@
-/* not empty */

solara/server/assets/favicon.svg

@@ -1,5 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svgjs="http://svgjs.com/svgjs" width="65" height="65"><svg width="65" height="65" viewBox="0 0 65 65" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M57.11 30.64L61.47 17.87L48.7 13.51L42.76 1.39999L30.65 7.34999L17.87 2.97999L13.51 15.75L1.40002 21.7L7.35002 33.81L2.99002 46.58L15.76 50.94L21.71 63.06L33.82 57.11L46.59 61.47L50.95 48.7L63.06 42.75L57.11 30.64ZM54.26 34.39L34.39 54.26C33.19 55.46 31.25 55.46 30.05 54.26L10.2 34.4C9.00002 33.2 9.00002 31.26 10.2 30.07L30.06 10.2C31.26 8.99999 33.2 8.99999 34.4 10.2L54.27 30.07C55.47 31.27 55.47 33.21 54.27 34.4L54.26 34.39Z" fill="#FFCF64"></path>
-<path d="M53.62 19.42L51.65 6.07L38.3 8.04L27.46 0L19.42 10.84L6.07 12.82L8.04 26.17L0 37L10.84 45.04L12.81 58.39L26.16 56.42L37 64.46L45.04 53.62L58.39 51.64L56.42 38.29L64.46 27.45L53.62 19.4V19.42ZM52.8 24.06L44.24 50.82C43.72 52.43 42 53.32 40.39 52.81L13.63 44.25C12.02 43.74 11.13 42.01 11.64 40.4L20.21 13.64C20.72 12.03 22.45 11.14 24.06 11.65L50.82 20.21C52.43 20.72 53.32 22.45 52.81 24.06H52.8Z" fill="#FF8C3E"></path>
-</svg><style>@media (prefers-color-scheme: light) { :root { filter: none; } }
-</style></svg>