bokeh 3.10.0.dev9__tar.gz → 3.10.0.dev10__tar.gz

{bokeh-3.10.0.dev9/src/bokeh.egg-info → bokeh-3.10.0.dev10}/PKG-INFO

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

{bokeh-3.10.0.dev9 → bokeh-3.10.0.dev10}/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,6 +42,7 @@ from typing import (
 # Bokeh imports
 from ..document import Document
 from ..settings import settings
+from ..util.asyncio import _run_in_executor
 
 if TYPE_CHECKING:
     from ..core.types import ID
@@ -258,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-3.10.0.dev9 → bokeh-3.10.0.dev10}/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-3.10.0.dev9 → bokeh-3.10.0.dev10}/src/bokeh/core/has_props.py

@@ -46,11 +46,6 @@ from typing import (
 )
 from weakref import WeakSet
 
-if TYPE_CHECKING:
-    def lru_cache[F: Callable[..., Any]](arg: int | None) -> Callable[[F], F]: ...
-else:
-    from functools import lru_cache
-
 # Bokeh imports
 from ..settings import settings
 from ..util.strings import append_docstring
@@ -114,22 +109,92 @@ def is_DataModel(cls: type[HasProps]) -> bool:
     from ..model import DataModel
     return issubclass(cls, HasProps) and getattr(cls, "__data_model__", False) and cls != DataModel
 
-def _overridden_defaults(class_dict: dict[str, Any]) -> dict[str, Any]:
-    overridden_defaults: dict[str, Any] = {}
-    for name, prop in tuple(class_dict.items()):
-        if isinstance(prop, Override):
-            del class_dict[name]
-            if prop.default_overridden:
-                overridden_defaults[name] = prop.default
-    return overridden_defaults
+class _PropertyInfo:
+    """Property metadata compiled once for each ``HasProps`` subclass."""
+
+    own_properties: dict[str, Property[Any]]
+    own_overridden_defaults: dict[str, Any]
+
+    _properties: dict[str, Property[Any]]
+    _property_names: set[str]
+    _descriptors: list[PropertyDescriptor[Any]]
+    _properties_with_refs: dict[str, Property[Any]]
+    _dataspecs: dict[str, DataSpec]
+    _overridden_defaults: dict[str, Any]
+
+    def __init__(self, own_properties: dict[str, Property[Any]], own_overridden_defaults: dict[str, Any]) -> None:
+        self.own_properties = own_properties
+        self.own_overridden_defaults = own_overridden_defaults
+
+    def _initialize(self, cls: type[HasProps]) -> None:
+        if hasattr(self, "_properties"):
+            return
+
+        properties: dict[str, Property[Any]] = {}
+        overridden_defaults: dict[str, Any] = {}
+
+        for base in reversed(cls.__mro__):
+            properties.update(getattr(base, "__properties__", {}))
+            overridden_defaults.update(getattr(base, "__overridden_defaults__", {}))
+
+        self._properties = properties
+        self._property_names = set(properties)
+        self._descriptors = [getattr(cls, name) for name in properties]
+        self._properties_with_refs = {name: prop for name, prop in properties.items() if prop.has_ref}
+        self._overridden_defaults = overridden_defaults
+
+    def properties(self, cls: type[HasProps]) -> dict[str, Property[Any]]:
+        self._initialize(cls)
+        return self._properties
+
+    def property_names(self, cls: type[HasProps]) -> set[str]:
+        self._initialize(cls)
+        return self._property_names
+
+    def descriptors(self, cls: type[HasProps]) -> list[PropertyDescriptor[Any]]:
+        self._initialize(cls)
+        return self._descriptors
+
+    def properties_with_refs(self, cls: type[HasProps]) -> dict[str, Property[Any]]:
+        self._initialize(cls)
+        return self._properties_with_refs
 
-def _generators(class_dict: dict[str, Any]):
+    def dataspecs(self, cls: type[HasProps]) -> dict[str, DataSpec]:
+        self._initialize(cls)
+        if not hasattr(self, "_dataspecs"):
+            from .property.dataspec import DataSpec  # avoid circular import
+
+            self._dataspecs = {name: prop for name, prop in self._properties.items() if isinstance(prop, DataSpec)}
+        return self._dataspecs
+
+    def overridden_defaults(self, cls: type[HasProps]) -> dict[str, Any]:
+        self._initialize(cls)
+        return self._overridden_defaults
+
+
+def _compile_property_info(class_name: str, class_dict: dict[str, Any]) -> _PropertyInfo:
+    own_properties: dict[str, Property[Any]] = {}
+    own_overridden_defaults: dict[str, Any] = {}
     generators: dict[str, PropertyDescriptorFactory[Any]] = {}
-    for name, generator in tuple(class_dict.items()):
-        if isinstance(generator, PropertyDescriptorFactory):
+
+    for name, value in tuple(class_dict.items()):
+        if isinstance(value, Override):
+            del class_dict[name]
+            if value.default_overridden:
+                own_overridden_defaults[name] = value.default
+        elif isinstance(value, PropertyDescriptorFactory):
             del class_dict[name]
-            generators[name] = generator
-    return generators
+            generators[name] = value
+
+    for name, generator in generators.items():
+        for descriptor in generator.make_descriptors(name):
+            descriptor_name = descriptor.name
+            if descriptor_name in class_dict:
+                raise RuntimeError(f"Two property generators both created {class_name}.{descriptor_name}")
+            class_dict[descriptor_name] = descriptor
+            own_properties[descriptor_name] = descriptor.property
+
+    return _PropertyInfo(own_properties, own_overridden_defaults)
 
 class _ModelResolver:
     """ A class responsible for tracking of models and how to resolve them. """
@@ -181,55 +246,45 @@ class MetaHasProps(type):
     __properties__: dict[str, Property[Any]]
     __overridden_defaults__: dict[str, Any]
     __themed_values__: dict[str, Any]
+    __property_info__: _PropertyInfo
 
     def __new__(cls, class_name: str, bases: tuple[type, ...], class_dict: dict[str, Any]):
         '''
 
         '''
-        overridden_defaults = _overridden_defaults(class_dict)
-        generators = _generators(class_dict)
+        property_info = _compile_property_info(class_name, class_dict)
+        class_dict["__property_info__"] = property_info
+        class_dict["__properties__"] = property_info.own_properties
+        class_dict["__overridden_defaults__"] = property_info.own_overridden_defaults
 
-        properties = {}
+        new_cls = super().__new__(cls, class_name, bases, class_dict)
 
-        for name, generator in generators.items():
-            descriptors = generator.make_descriptors(name)
-            for descriptor in descriptors:
-                name = descriptor.name
-                if name in class_dict:
-                    raise RuntimeError(f"Two property generators both created {class_name}.{name}")
-                class_dict[name] = descriptor
-                properties[name] = descriptor.property
-
-        class_dict["__properties__"] = properties
-        class_dict["__overridden_defaults__"] = overridden_defaults
-
-        return super().__new__(cls, class_name, bases, class_dict)
-
-    def __init__(cls, class_name: str, bases: tuple[type, ...], _) -> None:
         # HasProps itself may not have any properties defined
         if class_name == "HasProps":
-            return
+            return new_cls
 
         # Check for improperly redeclared a Property attribute.
         base_properties: dict[str, Any] = {}
         for base in (x for x in bases if issubclass(x, HasProps)):
             base_properties.update(base.properties(_with_props=True))
-        own_properties = {k: v for k, v in cls.__dict__.items() if isinstance(v, PropertyDescriptor)}
+        own_properties = {k: v for k, v in new_cls.__dict__.items() if isinstance(v, PropertyDescriptor)}
         redeclared = own_properties.keys() & base_properties.keys()
         if redeclared:
             from ..util.warnings import warn
 
-            warn(f"Properties {redeclared!r} in class {cls.__name__} were previously declared on a parent "
+            warn(f"Properties {redeclared!r} in class {new_cls.__name__} were previously declared on a parent "
                  "class. It never makes sense to do this. Redundant properties should be deleted here, or on "
                  "the parent class. Override() can be used to change a default value of a base class property.",
                  RuntimeWarning)
 
         # Check for no-op Overrides
-        unused_overrides = cls.__overridden_defaults__.keys() - cls.properties(_with_props=True).keys()
+        unused_overrides = property_info.own_overridden_defaults.keys() - property_info.properties(new_cls).keys()
         if unused_overrides:
             from ..util.warnings import warn
 
-            warn(f"Overrides of {unused_overrides} in class {cls.__name__} does not override anything.", RuntimeWarning)
+            warn(f"Overrides of {sorted(unused_overrides)} in class {new_cls.__name__} do not override anything.", RuntimeWarning)
+
+        return new_cls
 
     @property
     def model_class_reverse_map(cls) -> dict[str, type[HasProps]]:
@@ -510,16 +565,13 @@ class HasProps(Serializable, metaclass=MetaHasProps):
 
     @overload
     @classmethod
-    @lru_cache(None)
     def properties(cls, *, _with_props: Literal[False] = False) -> set[str]: ...
 
     @overload
     @classmethod
-    @lru_cache(None)
-    def properties(cls, *, _with_props: Literal[True] = True) -> dict[str, Property[Any]]: ...
+    def properties(cls, *, _with_props: Literal[True]) -> dict[str, Property[Any]]: ...
 
     @classmethod
-    @lru_cache(None)
     def properties(cls, *, _with_props: bool = False) -> set[str] | dict[str, Property[Any]]:
         ''' Collect the names of properties on this class.
 
@@ -532,23 +584,16 @@ class HasProps(Serializable, metaclass=MetaHasProps):
             property names
 
         '''
-        props: dict[str, Property[Any]] = {}
-        for c in reversed(cls.__mro__):
-            props.update(getattr(c, "__properties__", {}))
-
-        if not _with_props:
-            return set(props)
-
-        return props
+        if _with_props:
+            return cls.__property_info__.properties(cls)
+        return cls.__property_info__.property_names(cls)
 
     @classmethod
-    @lru_cache(None)
     def descriptors(cls) -> list[PropertyDescriptor[Any]]:
         """ List of property descriptors in the order of definition. """
-        return [ cls.lookup(name) for name, _ in cls.properties(_with_props=True).items() ]
+        return cls.__property_info__.descriptors(cls)
 
     @classmethod
-    @lru_cache(None)
     def properties_with_refs(cls) -> dict[str, Property[Any]]:
         ''' Collect the names of all properties on this class that also have
         references.
@@ -560,10 +605,9 @@ class HasProps(Serializable, metaclass=MetaHasProps):
             set[str] : names of properties that have references
 
         '''
-        return {k: v for k, v in cls.properties(_with_props=True).items() if v.has_ref}
+        return cls.__property_info__.properties_with_refs(cls)
 
     @classmethod
-    @lru_cache(None)
     def dataspecs(cls) -> dict[str, DataSpec]:
         ''' Collect the names of all ``DataSpec`` properties on this class.
 
@@ -574,8 +618,7 @@ class HasProps(Serializable, metaclass=MetaHasProps):
             set[str] : names of ``DataSpec`` properties
 
         '''
-        from .property.dataspec import DataSpec  # avoid circular import
-        return {k: v for k, v in cls.properties(_with_props=True).items() if isinstance(v, DataSpec)}
+        return cls.__property_info__.dataspecs(cls)
 
     def properties_with_values(self, *, include_defaults: bool = True, include_undefined: bool = False) -> dict[str, Any]:
         ''' Collect a dict mapping property names to their values.
@@ -609,10 +652,7 @@ class HasProps(Serializable, metaclass=MetaHasProps):
             This is an implementation detail of ``Property``.
 
         '''
-        defaults: dict[str, Any] = {}
-        for c in reversed(cls.__mro__):
-            defaults.update(getattr(c, "__overridden_defaults__", {}))
-        return defaults
+        return cls.__property_info__.overridden_defaults(cls)
 
     def query_properties_with_values(self, query: Callable[[PropertyDescriptor[Any]], bool], *,
             include_defaults: bool = True, include_undefined: bool = False) -> dict[str, Any]:

{bokeh-3.10.0.dev9 → bokeh-3.10.0.dev10}/src/bokeh/core/has_props.pyi

@@ -6,7 +6,6 @@
 #-----------------------------------------------------------------------------
 
 # Standard library imports
-from functools import lru_cache
 from typing import (
     Any,
     Callable,
@@ -54,8 +53,6 @@ class MetaHasProps(type):
 
     def __new__(cls, class_name: str, bases: tuple[type, ...], class_dict: dict[str, Any]) -> type[HasProps]: ...
 
-    def __init__(cls, class_name: str, bases: tuple[type, ...], class_dict: dict[str, Any]) -> None: ...
-
     @property
     def model_class_reverse_map(cls) -> dict[str, type[HasProps]]: ...
 
@@ -119,15 +116,12 @@ class HasProps(Serializable, metaclass=MetaHasProps):
     def properties(cls, *, _with_props: Literal[True]) -> dict[str, Property[Any]]: ...
 
     @classmethod
-    @lru_cache(None)
     def descriptors(cls) -> list[PropertyDescriptor[Any]]: ...
 
     @classmethod
-    @lru_cache(None)
     def properties_with_refs(cls) -> dict[str, Property[Any]]: ...
 
     @classmethod
-    @lru_cache(None)
     def dataspecs(cls) -> dict[str, DataSpec]: ...
 
     def properties_with_values(self, *, include_defaults: bool = True, include_undefined: bool = False) -> dict[str, Any]: ...

{bokeh-3.10.0.dev9 → bokeh-3.10.0.dev10}/src/bokeh/core/property/descriptors.py

@@ -118,7 +118,7 @@ class _HasDocument(Protocol):
     document: Document | None
 
 class _HasOverriddenDefaults(Protocol):
-    __overridden_defaults__: dict[str, Any]
+    def _overridden_defaults(self) -> dict[str, Any]: ...
 
 class _HasTrigger(Protocol):
     def trigger(self, attr: str, old: Any, new: Any,
@@ -502,7 +502,7 @@ class PropertyDescriptor[T]:
     def has_unstable_default(self, obj: HasProps) -> bool:
         # _may_have_unstable_default() doesn't have access to overrides, so check manually
         return self.property._may_have_unstable_default() or \
-            self.is_unstable(cast(_HasOverriddenDefaults, obj).__overridden_defaults__.get(self.name, None))
+            self.is_unstable(cast(_HasOverriddenDefaults, obj)._overridden_defaults().get(self.name, None))
 
     @classmethod
     def is_unstable(cls, value: Any) -> TypeGuard[Callable[[], Any]]:

{bokeh-3.10.0.dev9 → bokeh-3.10.0.dev10}/src/bokeh/core/property/instance.py

@@ -164,8 +164,13 @@ def _sphinx_type_link(obj: Instance[Any]) -> str:
     if isinstance(obj._instance_type, types.FunctionType):
         return f"{property_link(obj)}"
     if isinstance(obj._instance_type, str):
-        return f"{property_link(obj)}({obj._instance_type!r})"
+        instance_type = obj._instance_type
+        try:
+            model = obj.instance_type
+        except (AttributeError, ImportError):
+            return f"{property_link(obj)}({instance_type!r})"
+    else:
+        model = obj.instance_type
 
-    model = obj.instance_type
     model_name = f"{model.__module__}.{model.__name__}"
     return f"{property_link(obj)}({model_link(model_name)})"

{bokeh-3.10.0.dev9 → bokeh-3.10.0.dev10}/src/bokeh/document/__init__.py

@@ -43,6 +43,8 @@ __all__ = (
     'DEFAULT_TITLE',
     'Document',
     'DocumentLike',
+    'LockedCallback',
+    'LockedCallbackPolicy',
     'without_document_lock',
 )
 
@@ -52,7 +54,7 @@ __all__ = (
 
 from .document import DEFAULT_TITLE
 from .document import Document
-from .locking import UnlockedDocumentProxy, without_document_lock
+from .locking import LockedCallback, LockedCallbackPolicy, UnlockedDocumentProxy, without_document_lock
 
 type DocumentLike = Document | UnlockedDocumentProxy
 

{bokeh-3.10.0.dev9 → bokeh-3.10.0.dev10}/src/bokeh/document/callbacks.py

@@ -25,7 +25,12 @@ log = logging.getLogger(__name__)
 import weakref
 from collections import defaultdict
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Callable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+)
 
 # Bokeh imports
 from ..core.enums import HoldPolicy
@@ -80,7 +85,7 @@ __all__ = (
 )
 
 
-Callback = Callable[[], None]
+Callback = Callable[[], None | Awaitable[None]]
 Originator = Callable[..., Any]
 
 MessageCallback = Callable[[Any], None]
@@ -188,7 +193,7 @@ class DocumentCallbackManager:
         actual_callback: Callback
         if one_shot:
             @wraps(callback)
-            def remove_then_invoke() -> None:
+            def remove_then_invoke() -> None | Awaitable[None]:
                 if callback_obj in self._session_callbacks:
                     self.remove_session_callback(callback_obj)
                 return callback()
@@ -454,7 +459,7 @@ class DocumentCallbackManager:
 # Dev API
 #-----------------------------------------------------------------------------
 
-def invoke_with_curdoc(doc: Document, f: Callable[[], None]) -> None:
+def invoke_with_curdoc[T](doc: Document, f: Callable[[], T]) -> T:
     from ..io.doc import patch_curdoc
 
     curdoc: DocumentLike = UnlockedDocumentProxy(doc) if getattr(f, "nolock", False) else doc
@@ -498,7 +503,7 @@ def _combine_document_events(new_event: DocumentChangedEvent, old_events: list[D
 
 def _wrap_with_curdoc(doc: Document, f: Callable[..., Any]) -> Callable[..., Any]:
     @wraps(f)
-    def wrapper(*args: Any, **kwargs: Any) -> None:
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
         @wraps(f)
         def invoke() -> Any:
             return f(*args, **kwargs)

{bokeh-3.10.0.dev9 → bokeh-3.10.0.dev10}/src/bokeh/document/document.py

@@ -40,6 +40,7 @@ from json import loads
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Iterable,
     Literal,
     overload,
@@ -100,6 +101,7 @@ if TYPE_CHECKING:
     )
     from .events import DocumentChangeCallback
     from .json import DocJson, PatchJson
+    from .locking import LockedCallback, LockedCallbackPolicy
 
 #-----------------------------------------------------------------------------
 # Globals and constants
@@ -294,6 +296,68 @@ class Document:
         cb = NextTickCallback(callback=_no_op_callback, callback_id=make_id())
         return self.callbacks.add_session_callback(cb, callback, one_shot=True)
 
+    @overload
+    def locked_callback[**P](self, callback: Callable[P, Any], *, policy: LockedCallbackPolicy = "every") -> LockedCallback[P]: ...
+
+    @overload
+    def locked_callback[**P](self, callback: None = None, *, policy: LockedCallbackPolicy = "every") -> Callable[[Callable[P, Any]], LockedCallback[P]]: ...
+
+    def locked_callback[**P](
+        self, callback: Callable[P, Any] | None = None, *, policy: LockedCallbackPolicy = "every",
+    ) -> LockedCallback[P] | Callable[[Callable[P, Any]], LockedCallback[P]]:
+        ''' Decorate a callback to safely update this document from any thread.
+
+        The decorated function schedules its work on this document's server
+        session and executes with the document lock held. Calls return
+        immediately instead of returning the wrapped function's result.
+
+        Parentheses are optional when using the default policy. That is,
+        ``@doc.locked_callback`` and ``@doc.locked_callback()`` are equivalent.
+
+        Args:
+            callback (callable, optional):
+                The function to decorate when this method is used without
+                parentheses.
+
+            policy (``"every"`` or ``"latest"``, optional):
+                With ``"every"``, invoke the callback once for every call, in
+                order. With ``"latest"``, keep at most one waiting invocation,
+                replacing its arguments with those from the most recent call.
+
+        Returns:
+            A decorator that produces a
+            :class:`~bokeh.document.locking.LockedCallback`.
+
+        Example:
+
+            .. code-block:: python
+
+                @curdoc().locked_callback(policy="latest")
+                def update(value):
+                    source.data = value
+
+                @curdoc().locked_callback
+                def notify(value):
+                    status.text = value
+
+                # Safe to call from another thread:
+                update(new_data)
+
+        .. note::
+            Locked callbacks require a Bokeh server session and are closed
+            automatically when that session is destroyed.
+
+        '''
+        from .locking import LockedCallback
+
+        if callback is not None:
+            return LockedCallback(self, callback, policy=policy)
+
+        def decorator(callback: Callable[P, Any]) -> LockedCallback[P]:
+            return LockedCallback(self, callback, policy=policy)
+
+        return decorator
+
     def add_periodic_callback(self, callback: Callback, period_milliseconds: int) -> PeriodicCallback:
         ''' Add a callback to be invoked on a session periodically.