bokeh 4.0.0.dev1__tar.gz → 4.0.0.dev2__tar.gz

{bokeh-4.0.0.dev1/src/bokeh.egg-info → bokeh-4.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bokeh
-Version: 4.0.0.dev1
+Version: 4.0.0.dev2
 Summary: Interactive plots and applications in the browser from Python
 Author: Bokeh Team
 Author-email: info@bokeh.org

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/pyproject.toml

@@ -90,6 +90,7 @@ asyncio_mode = "auto"
 norecursedirs = "build _build node_modules tests/support"
 python_files = "*_tests.py *_test.py test_*.py"
 markers = [
+    "free_threading: a concurrency test relevant to free-threaded Python",
     "sampledata: a test for bokeh.sampledata",
     "selenium: a test as requiring selenium",
 ]
@@ -136,7 +137,7 @@ omit = ["*/sampledata/*", "*/sphinxext/*", "*/tmp/tmp*.py"]
 [tool.mypy]
 python_version = "3.12"
 mypy_path = "src/typings/"
-files = ["src/typings", "src/bokeh", "release", "tests"]
+files = ["src/typings", "src/bokeh", "tools", "tests"]
 
 strict = true
 
@@ -152,7 +153,7 @@ warn_return_any = false
 warn_unreachable = true
 
 [tool.pyright]
-include = ["src/bokeh"]
+include = ["src/bokeh", "tools"]
 extraPaths = ["src", "src/typings"]
 pythonVersion = "3.12"
 typeCheckingMode = "standard"
@@ -170,7 +171,7 @@ lint.exclude = [
     'node_modules',
 ]
 lint.per-file-ignores = {"__init__.py" = ["F403"]}
-lint.select = ["B", "COM", "E", "F", "NPY", "RUF", "TID", "UP", "W"]
+lint.select = ["B", "COM", "E", "F", "NPY", "PLC0414", "RUF", "TID", "UP", "W"]
 lint.ignore = [
     'B005', # Using .strip() with multi-character strings is misleading the reader
     'B006', # Do not use mutable data structures for argument defaults

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/src/bokeh/application/application.py

@@ -29,6 +29,7 @@ log = logging.getLogger(__name__)
 #-----------------------------------------------------------------------------
 
 # Standard library imports
+import inspect
 from abc import ABCMeta, abstractmethod
 from typing import (
     TYPE_CHECKING,
@@ -41,11 +42,11 @@ from typing import (
 # Bokeh imports
 from ..document import Document
 from ..settings import settings
+from ..util.asyncio import _run_in_executor
 
 if TYPE_CHECKING:
-    from tornado.httputil import HTTPServerRequest
-
     from ..core.types import ID
+    from ..server.request import RequestLike
     from ..server.session import ServerSession
     from .handlers.handler import Handler
 
@@ -74,10 +75,8 @@ class Application:
 
     '''
 
-    # This is so that bokeh.io.show can check if a passed in object is an
-    # Application without having to import Application directly. This module
-    # depends on tornado and we have made a commitment that "basic" modules
-    # will function without bringing in tornado.
+    # This lets bokeh.io.show identify an Application without importing the
+    # application and server-facing modules solely for an isinstance check.
     _is_a_bokeh_application_class: ClassVar[bool] = True
 
     _static_path: str | None
@@ -245,7 +244,7 @@ class Application:
             await h.on_session_destroyed(session_context)
         return None
 
-    def process_request(self, request: HTTPServerRequest) -> dict[str, Any]:
+    def process_request(self, request: RequestLike) -> dict[str, Any]:
         ''' Processes incoming HTTP request returning a dictionary of
         additional data to add to the session_context.
 
@@ -261,6 +260,21 @@ class Application:
             request_data.update(h.process_request(request))
         return request_data
 
+    async def process_request_async(self, request: RequestLike) -> dict[str, Any]:
+        ''' Asynchronously process an incoming HTTP request.
+
+        Synchronous handlers run in a worker, while handlers that return an
+        awaitable continue on the event loop. Handler ordering and dictionary
+        update semantics match :meth:`process_request`.
+        '''
+        request_data: dict[str, Any] = {}
+        for h in self._handlers:
+            result: Any = await _run_in_executor(h.process_request, request)
+            if inspect.isawaitable(result):
+                result = await result
+            request_data.update(result)
+        return request_data
+
 
 class ServerContext(metaclass=ABCMeta):
     ''' A harness for server-specific information and tasks related to

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/src/bokeh/application/handlers/code.py

@@ -48,7 +48,7 @@ from typing import (
 
 # Bokeh imports
 from ...io.doc import curdoc, patch_curdoc
-from .code_runner import CodeRunner
+from .code_runner import CodeRunner, _hold_process_globals
 from .handler import Handler
 
 if TYPE_CHECKING:
@@ -163,9 +163,8 @@ class CodeHandler(Handler):
         # paths to custom models resolver.
         doc.modules.add(module)
 
-        with _monkeypatch_io(self._loggers):
-            with patch_curdoc(doc):
-                self._runner.run(module, self._make_post_doc_check(doc))
+        with patch_curdoc(doc), _hold_process_globals(), _monkeypatch_io(self._loggers):
+            self._runner.run(module, self._make_post_doc_check(doc))
 
     def url_path(self) -> str | None:
         ''' The last path component for the basename of the configured filename.

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/src/bokeh/application/handlers/code_runner.py

@@ -25,8 +25,10 @@ log = logging.getLogger(__name__)
 import os
 import sys
 import traceback
+from contextlib import contextmanager
 from os.path import basename
-from typing import TYPE_CHECKING, Callable
+from threading import RLock
+from typing import TYPE_CHECKING, Callable, Generator
 
 # Bokeh imports
 from ...util.serialization import make_globally_unique_id
@@ -218,36 +220,48 @@ class CodeRunner:
                 are not met after code execution.
 
         '''
-        # Simulate the sys.path behaviour described here:
-        #
-        # https://docs.python.org/2/library/sys.html#sys.path
-        _cwd = os.getcwd()
-        _sys_path = list(sys.path)
-        _sys_argv = list(sys.argv)
-        sys.path.insert(0, os.path.dirname(self._path))
-        sys.argv = [os.path.basename(self._path), *self._argv]
-
         # XXX: self._code shouldn't be None at this point but types don't reflect this
         assert self._code is not None
 
-        try:
-            exec(self._code, module.__dict__)
+        with _hold_process_globals(), _patch_process_state(self._path, self._argv):
+            try:
+                exec(self._code, module.__dict__)
 
-            if post_check:
-                post_check()
-        except Exception as e:
-            handle_exception(self, e)
-        finally:
-            # undo sys.path, CWD fixups
-            os.chdir(_cwd)
-            sys.path = _sys_path
-            sys.argv = _sys_argv
-            self.ran = True
+                if post_check:
+                    post_check()
+            except Exception as e:
+                handle_exception(self, e)
+            finally:
+                self.ran = True
 
 #-----------------------------------------------------------------------------
 # Private API
 #-----------------------------------------------------------------------------
 
+_PROCESS_GLOBALS_LOCK = RLock()
+
+@contextmanager
+def _hold_process_globals() -> Generator[None, None, None]:
+    with _PROCESS_GLOBALS_LOCK:
+        yield
+
+@contextmanager
+def _patch_process_state(path: PathLike, argv: list[str]) -> Generator[None, None, None]:
+    # Simulate the sys.path behaviour described here:
+    #
+    # https://docs.python.org/2/library/sys.html#sys.path
+    old_cwd = os.getcwd()
+    old_sys_path = list(sys.path)
+    old_sys_argv = list(sys.argv)
+    sys.path.insert(0, os.path.dirname(path))
+    sys.argv = [os.path.basename(path), *argv]
+    try:
+        yield
+    finally:
+        os.chdir(old_cwd)
+        sys.path = old_sys_path
+        sys.argv = old_sys_argv
+
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/src/bokeh/application/handlers/directory.py

@@ -71,10 +71,9 @@ from .server_request_handler import ServerRequestHandler
 if TYPE_CHECKING:
     from types import ModuleType
 
-    from tornado.httputil import HTTPServerRequest
-
     from ...core.types import PathLike
     from ...document import Document
+    from ...server.request import RequestLike
     from ...themes import Theme
     from ..application import ServerContext, SessionContext
 
@@ -290,7 +289,7 @@ class DirectoryHandler(Handler):
         '''
         await self._lifecycle_handler.on_session_destroyed(session_context)
 
-    def process_request(self, request: HTTPServerRequest) -> dict[str, Any]:
+    def process_request(self, request: RequestLike) -> dict[str, Any]:
         ''' Processes incoming HTTP request returning a dictionary of
         additional data to add to the session_context.
 

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/src/bokeh/application/handlers/handler.py

@@ -49,9 +49,8 @@ import traceback
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from tornado.httputil import HTTPServerRequest
-
     from ...document import Document
+    from ...server.request import RequestLike
     from ..application import ServerContext, SessionContext
     from .code_runner import CodeRunner
 
@@ -193,7 +192,7 @@ class Handler:
         '''
         pass
 
-    def process_request(self, request: HTTPServerRequest) -> dict[str, Any]:
+    def process_request(self, request: RequestLike) -> dict[str, Any]:
         ''' Processes incoming HTTP request returning a dictionary of
         additional data to add to the session_context.
 

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/src/bokeh/application/handlers/lifecycle.py

@@ -22,6 +22,7 @@ log = logging.getLogger(__name__)
 #-----------------------------------------------------------------------------
 
 # Standard library imports
+import asyncio
 from typing import TYPE_CHECKING, Any, Callable
 
 # Bokeh imports
@@ -115,7 +116,8 @@ class LifecycleHandler(Handler):
             session_context (SessionContext) :
 
         '''
-        self._on_session_created(session_context)
+        if self._on_session_created is not _do_nothing:
+            await asyncio.to_thread(self._on_session_created, session_context)
 
     async def on_session_destroyed(self, session_context: SessionContext) -> None:
         ''' Execute ``on_session_destroyed`` from the configured module (if

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/src/bokeh/application/handlers/request_handler.py

@@ -28,7 +28,7 @@ from typing import TYPE_CHECKING, Any, Callable
 from .handler import Handler
 
 if TYPE_CHECKING:
-    from tornado.httputil import HTTPServerRequest
+    from ...server.request import RequestLike
 
 #-----------------------------------------------------------------------------
 # Globals and constants
@@ -51,7 +51,7 @@ class RequestHandler(Handler):
 
     '''
 
-    _process_request: Callable[[HTTPServerRequest], dict[str, Any]]
+    _process_request: Callable[[RequestLike], dict[str, Any]]
 
     def __init__(self) -> None:
         super().__init__()
@@ -59,7 +59,7 @@ class RequestHandler(Handler):
 
     # Public methods ----------------------------------------------------------
 
-    def process_request(self, request: HTTPServerRequest) -> dict[str, Any]:
+    def process_request(self, request: RequestLike) -> dict[str, Any]:
         ''' Processes incoming HTTP request returning a dictionary of
         additional data to add to the session_context.
 
@@ -80,7 +80,7 @@ class RequestHandler(Handler):
 # Private API
 #-----------------------------------------------------------------------------
 
-def _return_empty(request: HTTPServerRequest) -> dict[str, Any]:
+def _return_empty(request: RequestLike) -> dict[str, Any]:
     return {}
 
 #-----------------------------------------------------------------------------

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/src/bokeh/client/connection.py

@@ -33,10 +33,14 @@ from tornado.ioloop import IOLoop
 from tornado.websocket import WebSocketError, websocket_connect
 
 # Bokeh imports
-from ..protocol import Protocol
-from ..protocol.exceptions import MessageError, ProtocolError, ValidationError
-from ..protocol.messages.patch_doc import patch_doc
-from ..protocol.messages.pull_doc_reply import pull_doc_reply
+from ..protocol import (
+    patch_doc,
+    pull_doc_req,
+    push_doc,
+    replace_document,
+    sync,
+)
+from ..protocol.exceptions import ProtocolError
 from ..protocol.receiver import Receiver
 from ..util.strings import format_url_query_arguments
 from .states import (
@@ -55,7 +59,6 @@ if TYPE_CHECKING:
     from ..document import Document
     from ..document.events import DocumentPatchedEvent
     from ..protocol.message import Message
-    from ..protocol.messages.server_info_reply import ServerInfo
     from .session import ClientSession
 
 #-----------------------------------------------------------------------------
@@ -83,8 +86,6 @@ class ClientConnection:
     _loop: IOLoop
     _socket: WebSocketClientConnectionWrapper | None
     _until_predicate: Callable[[], bool] | None
-    _server_info: ServerInfo | None
-
     def __init__(self, session: ClientSession, websocket_url: str, io_loop: IOLoop | None = None,
             arguments: dict[str, str] | None = None, max_message_size: int = 20*1024*1024) -> None:
         ''' Opens a websocket connection to the server.
@@ -94,15 +95,13 @@ class ClientConnection:
         self._session = session
         self._arguments = arguments
         self._max_message_size = max_message_size
-        self._protocol = Protocol()
-        self._receiver = Receiver(self._protocol)
+        self._receiver = Receiver()
         self._socket = None
         self._state = NOT_YET_CONNECTED()
         # We can't use IOLoop.current because then we break
         # when running inside a notebook since ipython also uses it
         self._loop = io_loop if io_loop is not None else IOLoop()
         self._until_predicate = None
-        self._server_info = None
 
     # Properties --------------------------------------------------------------
 
@@ -178,7 +177,11 @@ class ClientConnection:
            None
 
         '''
-        self._send_request_server_info()
+        reply = self._send_message_wait_for_reply(sync())
+        if reply is None:
+            raise RuntimeError("Connection to server was lost during roundtrip")
+        if reply.msgtype != "OK":
+            raise RuntimeError(f"Unexpected reply {reply!r}")
 
     def loop_until_closed(self) -> None:
         ''' Execute a blocking loop that runs and executes event callbacks
@@ -210,16 +213,16 @@ class ClientConnection:
             None
 
         '''
-        msg = self._protocol.create('PULL-DOC-REQ')
+        msg = pull_doc_req()
         reply = self._send_message_wait_for_reply(msg)
         if reply is None:
             raise RuntimeError("Connection to server was lost")
         elif reply.header['msgtype'] == 'ERROR':
             raise RuntimeError("Failed to pull document: " + reply.content['text'])
         else:
-            if not isinstance(reply, pull_doc_reply):
+            if reply.msgtype != "PULL-DOC-REPLY":
                 raise RuntimeError(f"Unexpected reply {reply!r}")
-            reply.push_to_document(document)
+            replace_document(reply, document)
 
     def push_doc(self, document: Document) -> Message[Any]:
         ''' Push a document to the server, overwriting any existing server-side doc.
@@ -232,7 +235,7 @@ class ClientConnection:
             The server reply
 
         '''
-        msg = self._protocol.create('PUSH-DOC', document)
+        msg = push_doc(document)
         reply = self._send_message_wait_for_reply(msg)
         if reply is None:
             raise RuntimeError("Connection to server was lost")
@@ -241,23 +244,12 @@ class ClientConnection:
         else:
             return reply
 
-    def request_server_info(self) -> ServerInfo:
-        ''' Ask for information about the server.
-
-        Returns:
-            A dictionary of server attributes.
-
-        '''
-        if self._server_info is None:
-            self._server_info = self._send_request_server_info()
-        return self._server_info
-
     async def send_message(self, message: Message[Any]) -> None:
         if self._socket is None:
             log.info("We're disconnected, so not sending message %r", message)
         else:
             try:
-                sent = await message.send(self._socket)
+                sent = await self._socket.send_message(message)
                 log.debug("Sent %r [%d bytes]", message, sent)
             except WebSocketError as e:
                 # A thing that happens is that we detect the
@@ -309,8 +301,6 @@ class ClientConnection:
         else:
             if message.msgtype == 'PATCH-DOC':
                 log.debug("Got PATCH-DOC, applying to session")
-                if not isinstance(message, patch_doc):
-                    raise RuntimeError(f"Unexpected message {message!r}")
                 self._session._handle_patch(message)
             else:
                 log.debug("Ignoring %r", message)
@@ -357,11 +347,11 @@ class ClientConnection:
                 log.info("Connection closed by server")
                 return None
             try:
-                message = await self._receiver.consume(fragment)
+                message = self._receiver.consume(fragment)
                 if message is not None:
                     log.debug(f"Received message {message!r}")
                     return message
-            except (MessageError, ProtocolError, ValidationError) as e:
+            except ProtocolError as e:
                 log.error("%r", e, exc_info=True)
                 self.close(why="error parsing message from server")
 
@@ -386,16 +376,9 @@ class ClientConnection:
         return waiter.reply
 
     def _send_patch_document(self, session_id: ID, event: DocumentPatchedEvent) -> None:
-        msg = self._protocol.create('PATCH-DOC', [event])
+        msg = patch_doc([event])
         self._loop.add_callback(self.send_message, msg)
 
-    def _send_request_server_info(self) -> ServerInfo:
-        msg = self._protocol.create('SERVER-INFO-REQ')
-        reply = self._send_message_wait_for_reply(msg)
-        if reply is None:
-            raise RuntimeError("Did not get a reply to server info request before disconnect")
-        return reply.content
-
     def _tell_session_about_disconnect(self) -> None:
         if self._session:
             self._session._notify_disconnected()

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/src/bokeh/client/session.py

@@ -34,7 +34,12 @@ log = logging.getLogger(__name__)
 #-----------------------------------------------------------------------------
 
 # Standard library imports
-from typing import TYPE_CHECKING, Any, Literal
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    cast,
+)
 from urllib.parse import quote_plus
 
 # Bokeh imports
@@ -54,9 +59,9 @@ if TYPE_CHECKING:
         SessionCallbackRemoved,
     )
     from ..models.ui import UIElement
-    from ..protocol.messages.patch_doc import patch_doc
-    from ..protocol.messages.server_info_reply import ServerInfo
+    from ..protocol.message import Message
     from ..server.callbacks import DocumentCallbackGroup
+    from ..util.asyncio import Loop
     from ..util.browser import BrowserLike, BrowserTarget
     from .connection import ClientConnection
     from .states import ErrorReason
@@ -317,7 +322,10 @@ class ClientSession:
         self._connection = ClientConnection(session=self, io_loop=io_loop, websocket_url=websocket_url, arguments=arguments, max_message_size=max_message_size)
 
         from ..server.callbacks import DocumentCallbackGroup
-        self._callbacks = DocumentCallbackGroup(self._connection.io_loop)
+
+        # Tornado's IOLoop exposes ``asyncio_loop`` at runtime, but its type
+        # declarations don't include that attribute required by ``Loop``.
+        self._callbacks = DocumentCallbackGroup(cast("Loop", self._connection.io_loop))
 
     def __enter__(self) -> ClientSession:
         '''
@@ -473,15 +481,6 @@ class ClientSession:
         if self._document is None:
             self._attach_document(doc)
 
-    def request_server_info(self) -> ServerInfo:
-        ''' Ask for information about the server.
-
-        Returns:
-            A dictionary of server attributes.
-
-        '''
-        return self._connection.request_server_info()
-
     def show(self, obj: UIElement | None = None, browser: str | None = None,
             new: Literal["tab", "window"] = "tab") -> None:
         ''' Open a browser displaying this session.
@@ -534,10 +533,11 @@ class ClientSession:
             session_id = generate_session_id()
         return session_id
 
-    def _handle_patch(self, message: patch_doc) -> None:
+    def _handle_patch(self, message: Message[Any]) -> None:
         document = self.document
         assert document is not None
-        message.apply_to_document(document, self)
+        from ..protocol import apply_patch
+        apply_patch(message, document, self)
 
     def _loop_until_closed(self) -> None:
         ''' Execute a blocking loop that runs and executes event callbacks

{bokeh-4.0.0.dev1 → bokeh-4.0.0.dev2}/src/bokeh/client/websocket.py

@@ -28,6 +28,9 @@ from typing import Any, Awaitable, Callable
 from tornado import locks
 from tornado.websocket import WebSocketClientConnection
 
+# Bokeh imports
+from ..protocol.message import Message
+
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
@@ -55,16 +58,14 @@ class WebSocketClientConnectionWrapper:
 
     # Internal methods --------------------------------------------------------
 
-    async def write_message(self, message: str | bytes, binary: bool = False, locked: bool = True) -> None:
-        ''' Write a message to the websocket after obtaining the appropriate
-        Bokeh Document lock.
-
-        '''
-        if locked:
-            with await self.write_lock.acquire():
-                self._socket.write_message(message, binary)
-        else:
-            self._socket.write_message(message, binary)
+    async def send_message(self, message: Message[Any]) -> int:
+        '''Write all fragments of a protocol message atomically.'''
+        sent = 0
+        with await self.write_lock.acquire():
+            for fragment, binary in message.fragments():
+                self._socket.write_message(fragment, binary)
+                sent += len(fragment)
+        return sent
 
     def close(self, code: int | None = None, reason: str | None = None) -> None:
         ''' Close the websocket. '''