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

solara/server/threaded.py

@@ -0,0 +1,75 @@
+import logging
+import threading
+import time
+from typing import Optional
+
+logger = logging.getLogger("solara.server.threaded")
+
+
+class ServerBase(threading.Thread):
+    name = "not set"
+
+    def __init__(self, port: int, host: str = "localhost", **kwargs):
+        self.port = port
+        self.host = host
+        self.base_url = f"http://{self.host}:{self.port}"
+
+        self.kwargs = kwargs
+        self.started = threading.Event()
+        self.stopped = threading.Event()
+        self.error: Optional[BaseException] = None
+        super().__init__(name="test-server-thread", daemon=True)
+
+    def run(self):
+        try:
+            logger.info("Starting main loop")
+            self.mainloop()
+        except BaseException as e:  # noqa
+            self.error = e
+            self.started.set()
+            logger.exception("Issue starting server")
+
+    def serve_threaded(self):
+        logger.debug("start thread")
+        self.start()
+        logger.debug("wait for thread to run")
+        self.started.wait()
+        if self.error:
+            raise self.error
+
+    def wait_until_serving(self, timeout: float = 10):
+        start = time.time()
+        while time.time() < start + timeout:
+            if self.has_started():
+                time.sleep(0.1)  # give some time to really start
+                return
+            time.sleep(0.05)
+        raise RuntimeError(f"Server at {self.base_url} does not seem to be running")
+
+    def serve(self):
+        raise NotImplementedError
+
+    def mainloop(self):
+        logger.info("serving at http://%s:%d" % (self.host, self.port))
+        try:
+            self.serve()
+        except:  # noqa: E722
+            logger.exception("Oops, server stopped unexpectedly")
+            raise
+        finally:
+            self.stopped.set()
+
+    def stop_serving(self):
+        logger.debug("stopping server")
+        self.signal_stop()
+        self.stopped.wait(10)
+        if not self.stopped.is_set():
+            logger.error("stopping server failed")
+        else:
+            logger.debug("stopped server")
+
+    def signal_stop(self):
+        pass
+
+    def has_started(self) -> bool:
+        return False

solara/server/utils.py

@@ -0,0 +1,30 @@
+import contextlib
+import logging
+import os
+import pdb
+import traceback
+
+from rich import print
+
+logger = logging.getLogger("solara.server")
+
+
+def start_error(title, msg, exception: Exception = None):
+    if exception:
+        traceback.print_exception(None, exception, exception.__traceback__)
+    print(f"[red]{title}:\n\t[blue]{msg}")  # noqa
+    os._exit(-1)
+
+
+@contextlib.contextmanager
+def pdb_guard():
+    from . import settings
+
+    try:
+        yield
+    except Exception:
+        if settings.main.use_pdb:
+            logger.exception("Exception, will be handled by debugger")
+            pdb.post_mortem()
+        else:
+            raise

solara/server/websocket.py

@@ -0,0 +1,45 @@
+"""
+abstract base class for websocket with a sync interface.
+Async implementation have to come up with a way how to do this sync (see e.g. the starlette implementation)
+"""
+
+import abc
+import json
+from typing import Union
+
+
+class WebSocketDisconnect(Exception):
+    pass
+
+
+class WebsocketWrapper(abc.ABC):
+    @abc.abstractmethod
+    def send_text(self, data: str) -> None:
+        pass
+
+    @abc.abstractmethod
+    def send_bytes(self, data: bytes) -> None:
+        pass
+
+    def send(self, data: Union[str, bytes]) -> None:
+        if isinstance(data, str):
+            self.send_text(data)
+        elif isinstance(data, bytes):
+            self.send_bytes(data)
+        else:
+            raise TypeError(f"{type(data)} not supported, only ")
+
+    def send_json(self, data):
+        self.send_text(json.dumps(data))
+
+    @abc.abstractmethod
+    def close(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    async def receive(self) -> Union[str, bytes]:
+        pass
+
+    async def receive_json(self):
+        text = await self.receive()
+        return json.loads(text)

solara/settings.py

@@ -0,0 +1,56 @@
+import os
+from typing import Optional
+
+import solara.util
+
+from .minisettings import BaseSettings, Field
+from .util import get_solara_home
+
+try:
+    import dotenv
+except ImportError:
+    pass
+else:
+    dotenv.load_dotenv()
+
+
+home = get_solara_home()
+if not home.exists():
+    try:
+        home.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        pass  # can fail in for instance docker when $HOME is not set/writable
+
+
+class Cache(BaseSettings):
+    type: str = Field("memory", env="SOLARA_CACHE", title="Type of cache, e.g. 'memory', 'disk', 'redis', or a multilevel cache, e.g. 'memory,disk'")
+    disk_max_size: str = Field("10GB", title="Maximum size for'disk' cache , e.g. 10GB, 500MB")
+    memory_max_size: str = Field("1GB", title="Maximum size for 'memory-size' cache, e.g. 10GB, 500MB")
+    memory_max_items: int = Field(128, title="Maximum number of items for 'memory' cache")
+    clear: bool = Field(False, title="Clear the cache on startup, only applies to disk and redis caches")
+    path: Optional[str] = Field(
+        os.path.join(home, "cache"), env="SOLARA_CACHE_PATH", title="Storage location for 'disk' cache. Defaults to `${SOLARA_HOME}/cache`"
+    )
+
+    class Config:
+        env_prefix = "solara_cache_"
+        case_sensitive = False
+        env_file = ".env"
+
+
+# in colab or vscode there is not solara cdn proxy available
+_should_use_proxy = not (solara.util.is_running_in_colab() or solara.util.is_running_in_vscode() or solara.util.is_running_in_voila())
+
+
+class Assets(BaseSettings):
+    cdn: str = "https://cdn.jsdelivr.net/npm/"
+    proxy: bool = _should_use_proxy
+
+    class Config:
+        env_prefix = "solara_assets_"
+        case_sensitive = False
+        env_file = ".env"
+
+
+assets: Assets = Assets()
+cache: Cache = Cache()