bokeh 3.10.0.dev8__tar.gz → 3.10.0.dev10__tar.gz

{bokeh-3.10.0.dev8/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.dev8
+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.dev8 → bokeh-3.10.0.dev10}/pyproject.toml

@@ -170,7 +170,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-3.10.0.dev8 → 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,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-3.10.0.dev8 → bokeh-3.10.0.dev10}/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-3.10.0.dev8 → bokeh-3.10.0.dev10}/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-3.10.0.dev8 → bokeh-3.10.0.dev10}/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-3.10.0.dev8 → bokeh-3.10.0.dev10}/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-3.10.0.dev8 → 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.dev8 → bokeh-3.10.0.dev10}/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-3.10.0.dev8 → bokeh-3.10.0.dev10}/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
@@ -57,6 +62,7 @@ if TYPE_CHECKING:
     from ..protocol.messages.patch_doc import patch_doc
     from ..protocol.messages.server_info_reply import ServerInfo
     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 +323,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:
         '''

{bokeh-3.10.0.dev8 → bokeh-3.10.0.dev10}/src/bokeh/core/enums.py

@@ -309,7 +309,7 @@ type AutoType = Literal["auto"]
 #: Context dependent keyword that specifies the automated, default, computed, etc. behavior.
 Auto = enumeration(AutoType)
 
-type AutosizeModeType = Literal["fit_columns", "fit_viewport", "force_fit", "none"]
+type AutosizeModeType = Literal["fit_columns", "fit_viewport", "force_fit", "ignore_viewport", "none"]
 #: Specify autosize mode for DataTable.
 AutosizeMode = enumeration(AutosizeModeType)
 

{bokeh-3.10.0.dev8 → 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.dev8 → 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.dev8 → bokeh-3.10.0.dev10}/src/bokeh/core/properties.py

@@ -126,14 +126,22 @@ DataSpec Properties
 .. autoclass:: AngleSpec
 .. autoclass:: BoolSpec
 .. autoclass:: ColorSpec
+.. autoclass:: DashPatternSpec
 .. autoclass:: DataSpec
 .. autoclass:: DistanceSpec
 .. autoclass:: FloatSpec
 .. autoclass:: FontSizeSpec
+.. autoclass:: FontStyleSpec
+.. autoclass:: HatchPatternSpec
+.. autoclass:: IntSpec
+.. autoclass:: LineCapSpec
+.. autoclass:: LineJoinSpec
 .. autoclass:: MarkerSpec
 .. autoclass:: NumberSpec
 .. autoclass:: SizeSpec
 .. autoclass:: StringSpec
+.. autoclass:: TextAlignSpec
+.. autoclass:: TextBaselineSpec
 .. autoclass:: UnitsSpec
 
 Helpers

{bokeh-3.10.0.dev8 → bokeh-3.10.0.dev10}/src/bokeh/core/property/dataspec.py

@@ -90,6 +90,7 @@ __all__ = (
     'StringSpec',
     'TextAlignSpec',
     'TextBaselineSpec',
+    'UnitsSpec',
 )
 
 #-----------------------------------------------------------------------------