ipystream 0.1.10__py3-none-any.whl

ipystream/async_debounce.py

@@ -0,0 +1,29 @@
+from functools import wraps
+from threading import Timer
+
+
+class AsyncDebouncer:
+    def __init__(self, wait: float):
+        self.wait = wait
+        self.timer = None
+
+    def __call__(self, func):
+        @wraps(func)
+        def wrapped(*args, **kwargs):
+            # 1. Cancel the existing timer if it exists
+            if self.timer is not None:
+                self.timer.cancel()
+
+            # 2. Define the work to be done
+            def call_it():
+                try:
+                    func(*args, **kwargs)
+                except Exception as e:
+                    # Catch errors so they don't silently kill the thread
+                    print(f"Error in debounced function: {e}")
+
+            # 3. Start a new timer (in a separate thread)
+            self.timer = Timer(self.wait, call_it)
+            self.timer.start()
+
+        return wrapped

ipystream/renderer.py

@@ -0,0 +1,30 @@
+import base64
+
+from ipywidgets import widgets
+from plotly.io._utils import validate_coerce_fig_to_dict
+import plotly.graph_objects as go
+
+
+def plotly_fig_to_html(fig: go.Figure):
+    # compute dimensions
+    fig_dict = validate_coerce_fig_to_dict(fig, True)
+    iframe_buffer = 20
+    layout = fig_dict.get("layout", {})
+
+    if layout.get("width", False):
+        width = str(layout["width"] + iframe_buffer) + "px"
+    else:
+        width = "100%"
+
+    if layout.get("height", False):
+        height = layout["height"] + iframe_buffer
+    else:
+        height = str(525 + iframe_buffer) + "px"
+
+    # build html
+    html_content = fig.to_html(full_html=True, include_plotlyjs="cdn")
+    encoded_html = base64.b64encode(html_content.encode("utf-8")).decode("ascii")
+    src_url = f"data:text/html;base64,{encoded_html}"
+    html_string = f'<iframe src="{src_url}" width="{width}" height="{height}" frameborder="0"></iframe>'
+
+    return widgets.HTML(value=html_string)

ipystream/stream.py

@@ -0,0 +1,297 @@
+import threading
+from typing import Any, Callable
+import pandas as pd
+import solara
+from ipydatagrid import DataGrid
+from IPython.core.display import Javascript
+from IPython.core.display_functions import clear_output, display
+from ipywidgets import HTML, HBox, IntText
+from pydantic import BaseModel
+from ipystream.async_debounce import AsyncDebouncer
+from ipystream.utils import (
+    proxy_display,
+    is_internal_counter,
+    proxy_update_display,
+    remove_internal_counter,
+    internal_counter_desc,
+)
+from ipystream.widget_currents_children import WidgetCurrentsChildren
+
+display_sep = "---------------------------------------------------------"
+
+
+class WidgetUpdater(BaseModel):
+    widgets: list[Any]
+    updater: Callable[[WidgetCurrentsChildren], None] | None
+    vertical: bool
+    title: str | None
+    split_hbox_after: int | None
+
+    def stream_down(
+        self,
+        parents,
+        currents,
+        currents_level,
+        level_obj,
+        first_display: bool,
+        last_level: bool,
+    ):
+        # disable all observed
+        self.disable_loading(level_obj, first_display, last_level)
+
+        with level_obj.lock:
+            wca = WidgetCurrentsChildren(
+                parents=parents,
+                currents=currents,
+                cache=level_obj.cache,
+                currents_level=currents_level,
+                vertical=self.vertical,
+            )
+            wca_cleaned = wca.remove_counter()
+            self.updater(wca_cleaned)
+
+            if first_display:
+                missing = len(wca_cleaned.currents) - len(currents) + 1
+                for _ in range(missing):
+                    currents.insert(len(currents) - 1, None)
+
+                for i, widg in enumerate(wca_cleaned.currents):
+                    currents[i] = widg
+
+                if self.title:
+                    proxy_display(title_html(self.title), None, wca.cache)
+
+            cache = wca_cleaned.cache
+            level_obj.cache = cache
+
+            # update counter
+            if is_internal_counter(currents[-1]):
+                c = currents[-1]
+                c.value = c.value + 1
+
+            if self.vertical:
+                for i, w in enumerate(wca_cleaned.currents):
+                    id = wca_cleaned.display_id(i)
+                    if first_display:
+                        proxy_display(w, id, cache)
+                    # else:
+                    #     proxy_update_display(w, id, cache)
+            else:
+                self.display_horizontal(currents_level, wca_cleaned, first_display)
+
+            if last_level:
+                level_obj.stream_update_done_count = (
+                    level_obj.stream_update_done_count + 1
+                )
+
+    def display_horizontal(self, currents_level, wca_cleaned, first_display):
+        cache = wca_cleaned.cache
+        id = str(currents_level)
+        if self.split_hbox_after and len(wca_cleaned.currents) > self.split_hbox_after:
+            box1 = HBox(wca_cleaned.currents[0 : self.split_hbox_after])  # noqa: E203
+            box2 = HBox(wca_cleaned.currents[self.split_hbox_after :])  # noqa: E203
+            id1 = f"{id}_1"
+            id2 = f"{id}_2"
+
+            if first_display:
+                proxy_display(box1, id1, cache)
+                proxy_display(box2, id2, cache)
+            else:
+                proxy_update_display(box1, id1, cache)
+                proxy_update_display(box2, id2, cache)
+
+        else:
+            box = HBox(wca_cleaned.currents)
+            if first_display:
+                proxy_display(box, id, cache)
+            else:
+                proxy_update_display(box, id, cache)
+
+    def stream_down_obs(
+        self, parents, currents, debouncer, currents_level, level_obj, last_level
+    ):
+        @debouncer
+        def widget_on_change(_):
+            self.stream_down(
+                parents, currents, currents_level, level_obj, False, last_level
+            )
+
+        for widget in parents:
+            widget.observe(widget_on_change, names="value")
+
+    def disable_loading(self, level_obj, first_display: bool, last_level: bool):
+        if not first_display:
+            level_to_widget = level_obj.level_to_widget
+            levels = list(level_to_widget.keys())
+            levels.sort()
+            levels.pop()
+
+            for lvl in levels:
+                widgets = level_to_widget[lvl].widgets
+
+                for w in widgets:
+                    if hasattr(w, "disabled"):
+                        if not last_level:
+                            w.disabled = True
+                        else:
+                            w.disabled = False
+
+
+def title_html(x):
+    x = f"<font size='4' style='font-weight:bold;line-height: 50px'>{x}</font>"
+    return HTML(x)
+
+
+class Stream(BaseModel):
+    debounce_sec: float = 1.0
+    level_to_widget: dict[int, WidgetUpdater] = {}
+    cache: dict = {}
+    lock: Any = None
+    stream_update_done_count: int = -1
+    debouncer: Any = None
+
+    def register(
+        self,
+        level,
+        widgets=None,
+        updater=None,
+        vertical=False,
+        title=None,
+        split_hbox_after=None,
+    ):
+        if not self.level_to_widget:
+            self.lock = threading.RLock()
+            # check_javascript()
+
+        if not widgets:
+            widgets = []
+
+        self.level_to_widget[level] = WidgetUpdater(
+            widgets=[f(self) for f in widgets],
+            updater=updater,
+            vertical=vertical,
+            title=title,
+            split_hbox_after=split_hbox_after,
+        )
+
+    def display_registered(self):
+        if not self.debouncer:
+            self.debouncer = AsyncDebouncer(self.debounce_sec)
+
+        css = "<style>.widget-radio-box {margin-right: 40px;}</style>"
+        display(HTML(css))
+
+        levels = list(self.level_to_widget.keys())
+        levels.sort()
+        for level_i, level in enumerate(levels):
+            wu = self.level_to_widget[level]
+            currents = wu.widgets
+
+            # otherwise display happens in wu.stream_down()
+            if level_i == 0:
+                if wu.title:
+                    proxy_display(title_html(wu.title), None, self.cache)
+                proxy_display(HBox(remove_internal_counter(currents)), None, self.cache)
+            print(display_sep)
+
+            level_below = level + 1
+            if level_below not in self.level_to_widget:
+                continue
+
+            self.level_to_widget[level].updater = self.level_to_widget[
+                level_below
+            ].updater
+            self.level_to_widget[level].vertical = self.level_to_widget[
+                level_below
+            ].vertical
+            self.level_to_widget[level].title = self.level_to_widget[level_below].title
+            self.level_to_widget[level].split_hbox_after = self.level_to_widget[
+                level_below
+            ].split_hbox_after
+
+            children = self.level_to_widget[level_below].widgets
+            int_txt = IntText(value=0, disabled=True, description=internal_counter_desc)
+            children.append(int_txt)
+
+            # init
+            last_level = level_i == len(levels) - 2
+            wu.stream_down(currents, children, level_below, self, True, last_level)
+
+            # update on change
+            wu.stream_down_obs(
+                currents, children, self.debouncer, level_below, self, last_level
+            )
+
+    def manually_update_stream(self, start_level=None, level_to_default_value=None):
+        levels = list(self.level_to_widget.keys())
+        levels.sort()
+        for level_i, level in enumerate(levels):
+            wu = self.level_to_widget[level]
+            currents = wu.widgets
+
+            level_below = level + 1
+            if level_below not in self.level_to_widget or (
+                start_level and level_below < start_level
+            ):
+                continue
+
+            children = self.level_to_widget[level_below].widgets
+            last_level = level_i == len(levels) - 2
+            manually_stream_down(
+                wu,
+                currents,
+                children,
+                level_below,
+                self,
+                level_to_default_value,
+                last_level,
+            )
+
+
+def manually_stream_down(
+    wu, parents, currents, currents_level, level_obj, level_to_default_value, last_level
+):
+    level = currents_level - 1
+    if level_to_default_value and level in level_to_default_value:
+        default_value = level_to_default_value[level]
+        wu.widgets[0].value = default_value
+
+    wca = WidgetCurrentsChildren(
+        parents=parents,
+        currents=currents,
+        cache=level_obj.cache,
+        currents_level=currents_level,
+        vertical=wu.vertical,
+    )
+    wca_cleaned = wca.remove_counter()
+    wu.updater(wca_cleaned)
+
+    cache = wca_cleaned.cache
+    level_obj.cache = cache
+
+    if not wu.vertical:
+        wu.display_horizontal(currents_level, wca_cleaned, False)
+
+    if last_level:
+        level_obj.stream_update_done_count = level_obj.stream_update_done_count + 1
+
+
+def check_javascript():
+    grid = DataGrid(pd.DataFrame({"0": [0]}), layout={"height": "10px"})
+    display(grid)
+
+    dl = solara.FileDownload("a", filename="a", label="a")
+    display(dl)
+
+    js = """
+var err = 'Click to show javascript ' + 'error';
+var isJsError = document.body.innerHTML.includes(err);
+
+if (isJsError){
+    alert('Browser will be refreshed to fully load Jupyter widgets');
+    window.location.reload();
+}
+"""
+
+    display(Javascript(js))
+    clear_output()

ipystream/utils.py

@@ -0,0 +1,38 @@
+from IPython.core.display_functions import display, update_display
+from ipywidgets import IntText
+
+internal_counter_desc = "#{[34_9azerfcd"
+quiet_display_key = "quiet_display"
+logs_key = "logs"
+
+
+def is_internal_counter(widget):
+    if not isinstance(widget, IntText):
+        return False
+
+    return widget.description == internal_counter_desc
+
+
+def remove_internal_counter(l):
+    return [x for x in l if not is_internal_counter(x)]
+
+
+def proxy_display(widg, display_id, cache):
+    if quiet_display_key in cache:
+        log(widg, display_id, cache)
+    else:
+        display(widg, display_id=display_id)
+
+
+def proxy_update_display(widg, display_id, cache):
+    if quiet_display_key in cache:
+        log(widg, display_id, cache)
+    else:
+        update_display(widg, display_id=display_id)
+
+
+def log(widg, display_id, cache):
+    if logs_key not in cache:
+        cache[logs_key] = {}
+
+    cache[logs_key][display_id] = widg

ipystream/voila/auth_wall_limit.py

@@ -0,0 +1,184 @@
+import asyncio
+import json
+from filelock import FileLock
+from jupyter_server.services.kernels.kernelmanager import MappingKernelManager
+from tornado.web import HTTPError
+from voila.handler import VoilaHandler
+from voila import voila_kernel_manager
+
+from ipystream.voila.kernel import (
+    get_kernel_manager,
+    get_original_shutdown_kernel,
+    _load_kernel_to_user,
+    _save_kernel_to_user,
+    KERNEL_TO_TOKEN_FILE,
+)
+from ipystream.voila.utils import get_token_from_headers
+
+MAX_KERNELS = 8
+KERNEL_CLEANUP_TIMEOUT_SEC = 20
+FILE_LOCK = "kernel.lock"
+
+
+def patch(log_user_fun, token_to_user_fun):
+    # --- Monkey-patch shutdown_kernel to block external calls ---
+    def controlled_shutdown_kernel(self, kernel_id, **kwargs):
+        return asyncio.ensure_future(asyncio.sleep(0))  # Dummy completed awaitable
+
+    MappingKernelManager.shutdown_kernel = controlled_shutdown_kernel
+
+    # --- Patch kernel manager factory to assign user from handler ---
+    _original_factory = voila_kernel_manager.voila_kernel_manager_factory
+
+    def patched_voila_kernel_manager_factory(*args, **kwargs):
+        VoilaKernelManagerCls = _original_factory(*args, **kwargs)
+
+        _original_get_rendered_notebook = VoilaKernelManagerCls.get_rendered_notebook
+
+        async def _patched_get_rendered_notebook(
+            self, notebook_name: str, extra_kernel_env_variables: dict = {}, **kwargs
+        ):
+            running = self.list_kernel_ids()
+            if len(running) >= MAX_KERNELS:
+                raise HTTPError(503)
+
+            token = None
+            user = None
+            headers = extra_kernel_env_variables.get("headers")
+            if headers:
+                headers_dict = json.loads(headers)
+                token = get_token_from_headers(headers_dict)
+
+            if token and token_to_user_fun:
+                user = token_to_user_fun(token)
+
+            with FileLock(FILE_LOCK):
+                if user:
+                    data = _load_kernel_to_user()
+                    await check_user_kernel_conflict(user, data)
+
+            # Call original method to get preheated kernel
+            (
+                render_task,
+                rendered_cache,
+                kernel_id,
+            ) = await _original_get_rendered_notebook(
+                self, notebook_name, extra_kernel_env_variables, **kwargs
+            )
+
+            # Map kernel to user if available
+            if user:
+                data = _load_kernel_to_user()
+                data_token = _load_kernel_to_user(KERNEL_TO_TOKEN_FILE)
+
+                data[kernel_id] = user
+                data_token[kernel_id] = token
+
+                if log_user_fun:
+                    with FileLock(FILE_LOCK):
+                        log_user_fun(token)
+
+                _save_kernel_to_user(data)
+                _save_kernel_to_user(data_token, KERNEL_TO_TOKEN_FILE)
+
+            return render_task, rendered_cache, kernel_id
+
+        VoilaKernelManagerCls.get_rendered_notebook = _patched_get_rendered_notebook
+        return VoilaKernelManagerCls
+
+    voila_kernel_manager.voila_kernel_manager_factory = (
+        patched_voila_kernel_manager_factory
+    )
+
+    async def check_user_kernel_conflict(user: str, data: dict):
+        global_kernel_manager = get_kernel_manager()
+
+        count = 0
+        for existing_kid, existing_user in data.items():
+            if existing_user == user:
+                count += 1
+                km_info = global_kernel_manager.kernel_model(existing_kid)
+                connections = km_info["connections"]
+                if connections == 0:
+                    # kill existing
+                    _original_shutdown_kernel = get_original_shutdown_kernel()
+                    await _original_shutdown_kernel(
+                        global_kernel_manager, existing_kid, now=True
+                    )
+                    continue
+
+                raise HTTPError(
+                    503, f"User '{user}' already has a running kernel ({existing_kid})"
+                )
+
+        if count > 2:
+            raise HTTPError(503, f"User '{user}' already has 2 running kernels")
+
+    # --- VoilaHandler 503 page ---
+    def custom_voila_write_error(self, status_code, **kwargs):
+        if status_code == 503:
+            html = f"""
+            <html>
+              <head>
+                <title>App Limit Reached</title>
+                <style>
+                  body {{
+                    font-family: Arial, sans-serif;
+                    background: #fafafa;
+                    color: #333;
+                    text-align: center;
+                    padding-top: 10%;
+                  }}
+                  .box {{
+                    display: inline-block;
+                    background: white;
+                    border: 1px solid #ccc;
+                    border-radius: 12px;
+                    padding: 30px 50px;
+                    box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+                  }}
+                  h1 {{
+                    color: #c0392b;
+                  }}
+                </style>
+              </head>
+              <body>
+                <div class="box">
+                  <h1>App Already Open</h1>
+                  <p>You have duplicated pages of the app opened.<br>
+                     Please re-use an existing tab or close extra ones.</p>
+                  <p>Closed pages kernels are cleaned up after {KERNEL_CLEANUP_TIMEOUT_SEC} seconds</p>
+                </div>
+              </body>
+            </html>
+            """
+            self.set_status(status_code)
+            self.set_header("Content-Type", "text/html")
+            self.finish(html)
+        elif status_code == 404:
+            html = f"""
+            <html>
+            <head><title>Not Found</title></head>
+            <body style="font-family:sans-serif;text-align:center;margin-top:10%;">
+                <h1>404: Page Not Found</h1>
+                <p>The page you're looking for doesn't exist or the session expired.</p>
+                <button onclick="goHome()">Go Home</button>
+            
+                <script>
+                  function goHome() {{
+                    const query = window.location.search;
+                    const target = '/' + (query ? query : '');
+                    window.location.href = target;
+                  }}
+                </script>
+            </body>
+            </html>
+            """
+            self.set_status(status_code)
+            self.set_header("Content-Type", "text/html")
+            self.finish(html)
+
+        else:
+            super(VoilaHandler, self).write_error(status_code, **kwargs)
+
+    VoilaHandler.write_error = custom_voila_write_error

ipystream/voila/cookie.py

@@ -0,0 +1,45 @@
+from ipystream.voila.utils import PARAM_KEY_TOKEN, is_sagemaker
+
+
+def add_v_cookie(Voila):
+    def v_cookie_wrapper(handler_class):
+        class VCookieHandler(handler_class):
+            async def prepare(self):
+                # Get the token from URL query parameters
+                v = self.get_argument(PARAM_KEY_TOKEN, None)
+                if v:
+                    # Set the cookie
+                    self.set_cookie(PARAM_KEY_TOKEN, v, path="/", httponly=True)
+                    host_info = self.request.host  # e.g., "localhost:8867"
+
+                    port = "8866"
+                    if ":" in host_info:
+                        port = host_info.split(":")[-1]
+
+                    # Redirect to clean URL
+                    self.redirect(clean_url(port))
+                    return
+
+                # Call parent prepare (sync or async)
+                parent_prepare = super().prepare()
+                if parent_prepare is not None:
+                    await parent_prepare
+
+        return VCookieHandler
+
+    _original_init_handlers = Voila.init_handlers
+
+    def _patched_init_handlers(self):
+        handlers = _original_init_handlers(self)
+
+        wrapped = []
+        for h in handlers:
+            pattern, handler_class, *rest = h
+            wrapped.append((pattern, v_cookie_wrapper(handler_class), *rest))
+        return wrapped
+
+    Voila.init_handlers = _patched_init_handlers
+
+
+def clean_url(port):
+    return f"/jupyterlab/default/proxy/{port}/" if is_sagemaker() else "/"

ipystream/voila/documentation.py

@@ -0,0 +1,30 @@
+import base64
+from ipywidgets import widgets
+
+
+def documentation_btn(html_content, button_text="Documentation"):
+    # Base64 encode the HTML content for safe embedding
+    b64_html = base64.b64encode(html_content.encode("utf-8")).decode("utf-8")
+
+    # Wrap button in a span to control alignment
+    js_code = f"""
+        <span style="display: inline-block !important; vertical-align: top !important; margin-top: -2px !important;">
+            <button onclick="
+                var b64 = '{b64_html}';
+                var html = atob(b64);
+                var newWin = window.open('about:blank', '_blank');
+                if (newWin) {{
+                    newWin.document.open();
+                    newWin.document.write(html);
+                    newWin.document.close();
+                }} else {{
+                    alert('Pop-up blocked!');
+                }}
+            " class="jupyter-button button-blue" style="
+                background-color: #673AB7 !important;
+                color: white !important;">
+                {button_text}
+            </button>
+        </span>
+    """
+    return widgets.HTML(js_code)