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

solara/server/threaded.py

@@ -1,75 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,44 +0,0 @@
-"""
-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

@@ -1,56 +0,0 @@
-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()