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

solara/cache.py

@@ -1,294 +0,0 @@
-import hashlib
-import inspect
-import logging
-import sys
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generic,
-    MutableMapping,
-    Optional,
-    TypeVar,
-    Union,
-    cast,
-    overload,
-)
-
-import cachetools
-import solara
-import solara.settings
-import solara.util
-import typing_extensions
-from reacton.utils import equals
-
-logger = logging.getLogger("solara.cache")
-
-# placeholder value for missing keys
-_DOES_NOT_EXIST = object()
-
-_global_values_used: Dict[Any, Dict[str, Any]] = {}
-
-
-T = TypeVar("T")
-R = TypeVar("R")
-K = TypeVar("K")
-V = TypeVar("V")
-P = typing_extensions.ParamSpec("P")
-
-Storage = MutableMapping[K, V]
-
-
-class Memory(cachetools.LRUCache):
-    def __init__(self, max_items=solara.settings.cache.memory_max_items):
-        super().__init__(maxsize=max_items)
-
-
-def _default_key(*args, **kwargs):
-    kwargs_tuple: Any = ()
-    for key, value in kwargs.items():
-        kwargs_tuple += (key, value)
-    return (args, kwargs_tuple)
-
-
-class MemoizedFunction(Generic[P, R]):
-    def __init__(self, function: Callable[P, R], key: Callable[P, R], storage: Optional[Storage], allow_nonlocals=False):
-        self.function = function
-        f: Callable = self.function
-        if not allow_nonlocals:
-            nonlocals = inspect.getclosurevars(f).nonlocals
-            if nonlocals:
-                raise ValueError(f"Memoized functions cannot depend on nonlocal variables, it now depends on {nonlocals}")
-        if sys.version_info[:2] < (3, 9):
-            # usedforsecurity is only available in Python 3.9+
-            codehash = hashlib.md5(f.__code__.co_code).hexdigest()
-        else:
-            codehash = hashlib.md5(f.__code__.co_code, usedforsecurity=False).hexdigest()  # type: ignore
-
-        self.function_key = (f.__qualname__, codehash)
-        current_globals = dict(inspect.getclosurevars(f).globals)
-        _global_values_used.setdefault(self.function_key, current_globals)
-        self._check_globals()
-        self.key = key
-        self._storage = storage
-        self.intrusive_cancel = True
-        # modifications to these are not thread safe
-        # but good enough for an indication
-        self.hits = 0
-        self.misses = 0
-
-    @property
-    def storage(self) -> Storage:
-        return self._storage if self._storage is not None else storage
-
-    def _check_globals(self):
-        globals = _global_values_used.get(self.function_key)
-        current_globals = dict(inspect.getclosurevars(self.function).globals)
-        if current_globals is not globals:
-            if not equals(current_globals, globals):
-                raise ValueError(
-                    f"Memoized functions depend on globals variables, but they changed. The first value was {globals}, but now it is {current_globals}"
-                )
-
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
-        self._check_globals()
-        key = (self.function_key, self.key(*args, **kwargs))
-        # if .get is atomic, we do not need to lock
-        value = cast(R, self.storage.get(key, _DOES_NOT_EXIST))
-        if value is _DOES_NOT_EXIST:
-            self.misses += 1
-            value = self.function(*args, **kwargs)
-            self.storage[key] = value
-        else:
-            self.hits += 1
-        return value
-
-    def use_thread(self, *args: P.args, **kwargs: P.kwargs) -> solara.Result[R]:
-        """Calls the function in a thread when not in cache, otherwise returns the cached value.
-
-        This is almost similar to a use_thread on the memoized function, except that
-        we ensure that if the function return value is already in the cache, we don't
-        have to wait for the thread to finish.
-
-        This can cause less flickering in the UI, since it will immediately return a
-        'FINISHED' result, instead of a 'RUNNING' result when possible.
-        """
-        key = (self.function_key, self.key(*args, **kwargs))
-
-        # we assume generating the key is cheap, but a storage.get might not be
-        # since it may have to ask the a server, so we wrap it in use_memo
-        def get_current():
-            return cast(R, self.storage.get(key, _DOES_NOT_EXIST))
-
-        value = solara.use_memo(get_current, dependencies=[key])
-
-        def do_work():
-            if value is _DOES_NOT_EXIST:
-                self.misses += 1
-                self._check_globals()
-                new_value = self.function(*args, **kwargs)
-                # TODO: what if someone else already put in the value?
-                # we do a check in vaex if it differs
-                # but we could also store a Future
-                self.storage[key] = new_value
-                return new_value
-            else:
-                # although we don't use the return value directly, it's still used on the next time result_thread is
-                # returned.
-                return value
-
-        result_thread: solara.Result[R] = solara.use_thread(do_work, dependencies=[key], intrusive_cancel=self.intrusive_cancel)
-        if value is _DOES_NOT_EXIST:
-            return result_thread
-        else:
-            self.hits += 1
-            # what are the semantics of cancel and retry here?
-            return solara.Result(value, state=solara.ResultState.FINISHED)
-
-
-@overload
-def memoize(
-    function: None = None,
-    key: None = None,
-    storage: Optional[Storage] = None,
-    allow_nonlocals=False,
-) -> Callable[[Callable[P, R]], MemoizedFunction[P, R]]:
-    ...
-
-
-@overload
-def memoize(
-    function: None = None,
-    key: Callable[P, R] = ...,
-    storage: Optional[Storage] = None,
-    allow_nonlocals=False,
-) -> Callable[[Callable[P, R]], MemoizedFunction[P, R]]:
-    ...
-
-
-@overload
-def memoize(
-    function: Callable[P, R],
-    key: None = None,
-    storage: None = None,
-    allow_nonlocals=False,
-) -> MemoizedFunction[P, R]:
-    ...
-
-
-def memoize(
-    function: Union[None, Callable[P, R]] = None,
-    key: Union[None, Callable[P, R]] = None,
-    storage: Optional[Storage] = None,
-    allow_nonlocals: bool = False,
-) -> Union[Callable[[Callable[P, R]], MemoizedFunction[P, R]], MemoizedFunction[P, R]]:
-    """Will cache function return values based on the arguments.
-
-    Example:
-
-    ```python
-    @solara.memoize
-    def mean(values):
-         return sum(values) / len(values)
-    ```
-
-    If a key function is provided, it will be used to generate the cache key based on the arguments instead.
-    This is useful in situations where the arguments are not hashable, but a unique key can be generated
-    based on the arguments.
-
-    Also used in situations where the arguments are expensive to hash, but a cheaper key
-    that is unique exists. For example using the filename instead of the file content.
-
-    Example:
-
-    ```python
-    @solara.memoize(key=lambda df, column: (id(df), column))
-    def mean(df, column):
-        return df[column].mean()
-    ```
-
-    Without the key function, the above would fail because a DataFrame is not hashable.
-
-    The function name and function code are added to the argument based key, together making up a unique cache key.
-    Nonlocals variables are not included in the key, and are not allowed by default. Pass `allow_nonlocals=True`
-    to allow nonlocals variables, or add them as arguments to the function.
-    Globals are by default allowed, and also not included in the key. Solara will try to detect if globals are
-    changed, and if so, will raise a ValueError.
-
-    If a storage is provided, it will be used to store the cached values. If no storage is provided, the
-    shared storage will be used. This is useful in situations where the cache should be shared between
-    different functions to avoid excessive memory usage by limiting the number of cache entries or the
-    memory content.
-
-    The storage can be any object that implements the MutableMapping interface, for instance a dict or
-    a cachetools.LRUCache. Or a new instance of `solara.cache.Memory`, see [caching](/documentation/getting_started/reference/caching)
-    for cache storage options.
-
-    The return value of the decorator behaves like the original function, but also has a few attributes:
-
-     * `storage`: the storage used to cache the values
-     * `key`: the key function used to generate the key
-     * `function`: the original function
-     * `use_thread`: a hook that will execute the function in a thread, and return a Result object
-        If the value is already cached, the function will not be executed in a thread.
-
-
-    See also the [reference on caching](/documentation/getting_started/reference/caching) for more caching details.
-
-    """
-
-    def wrapper(func: Callable[P, R]) -> MemoizedFunction[P, R]:
-        return MemoizedFunction[P, R](
-            func,
-            cast(Callable[P, R], key or _default_key),
-            storage,
-            allow_nonlocals,
-        )
-
-    if function is None:
-        return wrapper
-    else:
-        return wrapper(function)
-
-
-cache_type_map = {
-    "memory": "solara.cache.Memory",
-    "memory-size": "solara_enterprise.cache.memory_size.MemorySize",
-    "disk": "solara_enterprise.cache.disk.Disk",
-    "redis": "solara_enterprise.cache.redis.Redis",
-    "multi-level": "solara_enterprise.cache.multi_level.MultiLevel",
-}
-
-
-def create(name: str = "memory", *args, **kwargs) -> Storage:
-    """Create a cache storage based on the name.
-
-    ## Arguments
-
-     - `name`: the name of the cache type, can be one of `memory`, `memory-size`, `disk`, `redis`, `multi-level`
-     - `*args`: the arguments to pass to the cache constructor
-     - `**kwargs`: the keyword arguments to pass to the cache constructor
-
-    """
-    if "," in name:
-        names = name.split(",")
-        logger.info("Set multilevel cache to %r", names)
-        caches = []
-        for name in names:
-            caches.append(create(name, *args, **kwargs))
-        cache = create("multi-level", *caches)
-    elif name in cache_type_map:
-        cls = solara.util.import_item(cache_type_map[name])
-        cache = cls(*args, **kwargs)
-    else:
-        raise ValueError(f"Unknown type of cache {name}")
-    return cache
-
-
-storage: Storage = create(solara.settings.cache.type)
-
-
-def configure(name="memory", *args, **kwargs):
-    """Shorthand for solara.cache.storage = solara.cache.create(name, *args, **kwargs)"""
-    global storage
-    storage = create(name, *args, **kwargs)

solara/checks.html

@@ -1,71 +0,0 @@
-<div class="jupyter-widget-checks-container">
-    <script>
-        (function () {
-            console.log("Checking for jupyter-widgets extensions")
-            const inLab = window._JUPYTERLAB !== undefined;
-            const silent = jupyter_widget_checks_silent;
-            const containers = document.getElementsByClassName('jupyter-widget-checks-container');
-            const rootEl = containers[containers.length - 1];
-            const libraries = window.jupyter_widget_checks_libraries;
-
-            function getBaseUrl() {
-                const labConfigData = document.getElementById("jupyter-config-data");
-                if (labConfigData) {
-                    /* lab and Voila */
-                    return JSON.parse(labConfigData.textContent).baseUrl;
-                }
-                let base = document.body.dataset.baseUrl || document.baseURI;
-                return base;
-            }
-
-            function checkLibrary(extensions, library) {
-                let installed = false;
-                let ok = true;
-                if (inLab) {
-                    installed = _JUPYTERLAB[library.lab] !== undefined
-                } else {
-                    installed = extensions[library.classic] !== undefined;
-                    let enabled = extensions[library.classic] === true;
-                }
-                const div = document.createElement("div")
-                if (installed) {
-                    if (!silent) {
-                        div.innerHTML = `Extension ${library.python} is installed at the server ✅`
-                        rootEl.appendChild(div)
-                    }
-                } else {
-                    div.innerHTML = `Extension ${library.python} is <b>NOT</b> installed at the server ❌.`
-                    rootEl.appendChild(div)
-                    ok = false;
-                }
-                return ok;
-            }
-
-            async function check() {
-                const url = `${getBaseUrl()}api/config/notebook`
-                const response = (await fetch(url));
-                const data = await response.json()
-                const extensions = data["load_extensions"];
-                var ok = true;
-                let needsInstall = [];
-                libraries.forEach((library) => {
-                    if (!checkLibrary(extensions, library)) {
-                        ok = false;
-                        needsInstall.push(library.python)
-                        console.log("Needs install", library.python)
-                    }
-                })
-                console.log(ok, needsInstall)
-                if (!ok) {
-                    const div = document.createElement("div")
-                    const div2 = document.createElement("div")
-                    div.innerHTML = `Run <code>${jupyter_python_executable} -m pip install ${needsInstall.join(" ")}</code>. Refresh the page after installation.`
-                    div2.innerHTML = `Visit <a href="https://solara.dev/documentation/getting_started/troubleshoot" target="_blank">https://solara/dev/documentation/getting_started/troubleshoot</a> for more information.`
-                    rootEl.appendChild(div)
-                    rootEl.appendChild(div2)
-                }
-            }
-            check()
-        })();
-    </script>
-</div>

solara/checks.py

@@ -1,224 +0,0 @@
-import json
-import logging
-import os
-import subprocess
-import sys
-import warnings
-from pathlib import Path
-from typing import Optional
-
-import IPython.display
-from IPython.core.interactiveshell import InteractiveShell
-from IPython.display import display
-
-import solara
-from solara.util import get_solara_home
-
-HERE = Path(__file__).parent
-logger = logging.getLogger(__name__)
-
-jupyter_checked_path = get_solara_home() / ".jupyter_checked"
-solara_checked_path = get_solara_home() / ".solara_checked"
-solara_version = solara.__version__
-
-
-def _should_perform_check(path: Path):
-    if path.exists():
-        return False
-    try:
-        home = get_solara_home()
-        if not home.exists():
-            home.mkdir(parents=True, exist_ok=True)
-        # try writing, if we cannot, we will not check
-        if not path.exists():
-            path.write_text("")
-            path.unlink()
-    except OSError:
-        return False
-    return True
-
-
-def should_perform_jupyter_check():
-    if "PYTEST_CURRENT_TEST" in os.environ:
-        return False
-    return _should_perform_check(jupyter_checked_path)
-
-
-def should_perform_solara_check():
-    if "PYTEST_CURRENT_TEST" in os.environ:
-        return False
-    import solara.server.settings
-
-    if solara.server.settings.main.mode == "production":
-        return False
-    return _should_perform_check(solara_checked_path)
-
-
-@solara.component
-def JupyterCheck():
-    # We do 2 calls home:
-    #  * 1 from pure js (should always work)
-    #  * 1 from a widget (might not work)
-    # This way we can see how many installations actually fail
-    # Note that we only do this once, we touch ~/.solara/.jupyter_checked
-    # to avoid doing it multiple times
-    def inject_pure_js_check():
-        # do this as an effect, otherwise we will use the display
-        # that gets dispatched to solara, which will not come through
-        # if the widgets do not work
-        IPython.display.display(
-            IPython.display.Javascript(
-                data=f"""
-const prevIframe = document.getElementById("solara-jupyter-check");
-if(prevIframe)
-    prevIframe.remove();
-const iframe = document.createElement('iframe')
-iframe.setAttribute("src", "https://solara.dev/static/public/success.html?check=purejs&version={solara_version}");
-iframe.style.width = "0px";
-iframe.style.height = "0px";
-iframe.style.display = "none";
-iframe.id = "solara-jupyter-check";
-document.body.appendChild(iframe);
-            """
-            )
-        )
-
-    # this should always get through, even if widgets do not work
-    solara.use_effect(inject_pure_js_check, [])
-
-    def flag_jupyter_checked():
-        try:
-            jupyter_checked_path.write_text("")
-        except OSError:
-            pass
-
-    solara.use_effect(flag_jupyter_checked, [])
-    # this iframe should only get through if the widget installation succeeded
-    return solara.v.Html(
-        tag="iframe",
-        attributes={"src": f"https://solara.dev/static/public/success.html?check=widget&version={solara_version}", "width": "0px", "height": "0px"},
-        style_="display: none;",
-    )
-
-
-@solara.component
-def SolaraCheck():
-    def flag_solara_checked():
-        try:
-            solara_checked_path.write_text("")
-        except OSError:
-            pass
-
-    solara.use_effect(flag_solara_checked, [])
-    return solara.v.Html(
-        tag="iframe",
-        attributes={
-            "src": f"https://solara.dev/static/public/success.html?system=solara&check=widget&version={solara_version}",
-            "width": "0px",
-            "height": "0px",
-        },
-        style_="display: none;",
-    )
-
-
-def getcmdline(pid):
-    # for linux
-    if sys.platform == "linux":
-        with open(f"/proc/{pid}/cmdline", "rb") as f:
-            return f.read().split(b"\00")[0].decode("utf-8")
-    elif sys.platform == "darwin":
-        return subprocess.check_output(["ps", "-o", "command=", "-p", str(pid)]).split(b"\n")[0].split(b" ")[0].decode("utf-8")
-    elif sys.platform == "win32":
-        return subprocess.check_output(["wmic", "process", "get", "commandline", "/format:list"]).split(b"\n")[0].split(b" ")[0].decode("utf-8")
-    else:
-        raise ValueError(f"Unsupported platform: {sys.platform}")
-
-
-def get_server_python_executable(silent: bool = False):
-    servers = []
-    try:
-        from jupyter_server import serverapp
-
-        servers += list(serverapp.list_running_servers())
-    except ImportError:
-        pass
-    try:
-        from notebook import notebookapp
-
-        servers += list(notebookapp.list_running_servers())
-    except ImportError:
-        pass
-
-    pythons = [getcmdline(server["pid"]) for server in servers]
-    if len(pythons) == 0:
-        python = sys.executable
-        if not silent:
-            warnings.warn("Could not find servers, we are assuming the server is running under Python executable: %s" % python)
-    elif len(pythons) > 1:
-        info = "\n\t".join(pythons)
-        if sys.executable in pythons:
-            python = sys.executable
-        else:
-            python = pythons[0]
-            if not silent:
-                warnings.warn("Found multiple find servers:\n%s\n" "We are assuming the server is running under Python executable: %s" % (info, python))
-    else:
-        python = pythons[0]
-    return python
-
-
-libraries_minimal = [
-    {"python": "ipyvuetify", "classic": "jupyter-vuetify/extension", "lab": "jupyter-vuetify"},
-    {"python": "ipyvue", "classic": "jupyter-vue/extension", "lab": "jupyter-vue"},
-]
-
-libraries_extra = [
-    {"python": "bqplot", "classic": "bqplot/extension", "lab": "bqplot"},
-    {"python": "ipyvolume", "classic": "ipyvolume/extension", "lab": "ipyvolume"},
-    {"python": "ipywebrtc", "classic": "jupyter-webrtc", "lab": "jupyter-webrtc"},
-    {"python": "ipyleaflet", "classic": "ipyleaflet/extension", "lab": "ipyleaflet"},
-]
-
-
-def check_jupyter(
-    server_python: Optional[str] = None,
-    silent: bool = False,
-    libraries: list = libraries_minimal,
-    libraries_extra: list = libraries_extra,
-    force: bool = False,
-    extra: bool = False,
-):
-    if solara._using_solara_server():
-        # for the server we don't need to do this check
-        return
-    if not InteractiveShell.initialized():
-        # also, in a normal python repr, we don't want to display anything
-        return
-    try:
-        python_executable = server_python or get_server_python_executable(silent)
-        if Path(python_executable).resolve() != Path(sys.executable).resolve() or force:
-            libraries_json = json.dumps(libraries + (libraries_extra if extra else []))
-            display(
-                IPython.display.Javascript(
-                    data="""
-                    window.jupyter_python_executable = %r;
-                    window.jupyter_widget_checks_silent = %s;
-                    window.jupyter_widget_checks_libraries = %s;
-                    """
-                    % (python_executable, str(silent).lower(), libraries_json)
-                )
-            )
-            display(IPython.display.HTML(filename=str(HERE / "checks.html")))
-        else:
-            if not silent:
-                display(
-                    IPython.display.HTML(
-                        data="<div>Jupyter server is running under the same Python executable as your kernel, no need to check 👍."
-                        "<br> <i>Run solara.check_jupyter(force=True) to force checking.</i></div>"
-                    )
-                )
-    except Exception:
-        logger.exception("Could not check jupyter-widgets extensions.")
-
-
-check_jupyter(silent=True)

solara/comm.py

@@ -1,28 +0,0 @@
-import traceback
-from typing import Any, Dict
-
-try:
-    import comm
-except ImportError:
-    comm = None  # type: ignore
-
-orphan_comm_stacks: Dict[Any, str] = {}
-
-
-if comm is not None and comm.create_comm is comm._create_comm:
-    # only when nobody else has monkey-patched comm.create_comm
-    class DummyComm(comm.base_comm.BaseComm):  # type: ignore
-        def publish_msg(self, msg_type, data=None, metadata=None, buffers=None, **keys):
-            pass
-
-    def create_dummy_comm(*args, **kwargs):
-        comm = DummyComm(*args, **kwargs)
-        stacktrace = "".join(traceback.format_stack())
-        orphan_comm_stacks[comm] = stacktrace
-        return comm
-
-    comm.create_comm = create_dummy_comm
-else:
-
-    class DummyComm:  # type: ignore
-        pass

solara/components/__init__.py

@@ -1,59 +0,0 @@
-# isort: skip_file
-from .button import Button  # noqa: F401
-from .style import Style  # noqa: F401 F403
-from .misc import *  # noqa: #F401 F403
-from .alert import Warning, Info, Error, Success  # noqa: #F401 F403
-from .checkbox import Checkbox  # noqa: #F401 F403
-from .cross_filter import (  # noqa: F401
-    CrossFilterDataFrame,
-    CrossFilterReport,
-    CrossFilterSelect,
-    CrossFilterSlider,
-)
-from .datatable import DataTable, DataFrame  # noqa: #F401 F403
-from .details import Details  # noqa: #F401 F403
-from .file_browser import FileBrowser  # noqa: #F401 F403
-from .image import Image  # noqa: #F401 F403
-from .markdown import Markdown, MarkdownIt  # noqa: #F401 F403
-from .slider import (  # noqa: F401 F403
-    DateSlider,  # noqa: F401 F403
-    FloatSlider,  # noqa: F401 F403
-    IntSlider,  # noqa: F401 F403
-    ValueSlider,  # noqa: F401 F403
-    SliderDate,  # noqa: F401 F403
-    SliderFloat,  # noqa: F401 F403
-    SliderInt,  # noqa: F401 F403
-    SliderValue,  # noqa: F401 F403
-    SliderRangeInt,  # noqa: F401 F403
-    SliderRangeFloat,  # noqa: F401 F403
-)  # noqa: F401 F403
-from .sql_code import SqlCode  # noqa: #F401 F403
-from .togglebuttons import (  # noqa: #F401 F403
-    ToggleButtonsMultiple,
-    ToggleButtonsSingle,
-)
-from .input import InputText, InputFloat, InputInt  # noqa: #F401 F403
-from .pivot_table import PivotTableView, PivotTable, PivotTableCard  # noqa: #F401 F403
-from .head import Head  # noqa: #F401 F403
-from .title import Title  # noqa: #F401 F403
-from .link import Link  # noqa: #F401 F403
-from .applayout import AppLayout, Sidebar, AppBar, AppBarTitle  # noqa: #F401 F403
-from .tab_navigation import TabNavigation  # noqa: #F401 F403
-from .markdown_editor import MarkdownEditor  # noqa: #F401 F403
-from .select import Select, SelectMultiple  # noqa: #F401 F403
-from .matplotlib import FigureMatplotlib  # noqa: #F401 F403
-from .echarts import FigureEcharts  # noqa: #F401 F403
-from .figure_altair import FigureAltair, AltairChart  # noqa: #F401 F403
-from .meta import Meta  # noqa: #F401 F403
-from .columns import Columns, ColumnsResponsive  # noqa: #F401 F403
-from .file_drop import FileDrop, FileDropMultiple  # noqa: #F401 F403
-from .file_download import FileDownload  # noqa: #F401 F403
-from .tooltip import Tooltip  # noqa: #F401 F403
-from .card import Card, CardActions  # noqa: #F401 F403
-from .spinner import SpinnerSolara  # noqa: #F401 F403
-from .switch import Switch  # noqa: #F401 F403
-from .progress import ProgressLinear  # noqa: #F401 F403
-from .component_vue import _component_vue, component_vue  # noqa: #F401 F403
-import reacton.core
-
-reacton.core._default_container = Column  # noqa: F405