bokeh 3.9.0.dev2__tar.gz → 3.9.0.dev4__tar.gz

{bokeh-3.9.0.dev2/src/bokeh.egg-info → bokeh-3.9.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bokeh
-Version: 3.9.0.dev2
+Version: 3.9.0.dev4
 Summary: Interactive plots and applications in the browser from Python
 Author: Bokeh Team
 Author-email: info@bokeh.org
@@ -44,7 +44,6 @@ Requires-Dist: contourpy>=1.2
 Requires-Dist: narwhals>=1.13
 Requires-Dist: numpy>=1.16
 Requires-Dist: packaging>=16.8
-Requires-Dist: pandas>=1.2
 Requires-Dist: pillow>=7.1.0
 Requires-Dist: PyYAML>=3.10
 Requires-Dist: tornado>=6.2; sys_platform != "emscripten"

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/pyproject.toml

@@ -14,7 +14,6 @@ dependencies = [
     "narwhals>=1.13",
     "numpy >=1.16",
     "packaging >=16.8",
-    "pandas >=1.2",
     "pillow >=7.1.0",
     "PyYAML >=3.10",
     "tornado >=6.2; sys_platform != 'emscripten'",

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/client/connection.py

@@ -153,7 +153,7 @@ class ClientConnection:
         def connected_or_closed() -> bool:
             # we should be looking at the same state here as the 'connected' property above, so connected
             # means both connected and that we did our initial message exchange
-            return isinstance(self._state, CONNECTED_AFTER_ACK | DISCONNECTED)
+            return isinstance(self._state, (CONNECTED_AFTER_ACK, DISCONNECTED))
         self._loop_until(connected_or_closed)
 
     def close(self, why: str = "closed") -> None:

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/core/has_props.pyi

@@ -45,6 +45,11 @@ def is_abstract(cls: type[HasProps]) -> bool: ...
 
 def is_DataModel(cls: type[HasProps]) -> bool: ...
 
+class _ModelResolver:
+    ...
+
+_default_resolver: _ModelResolver
+
 class MetaHasProps(type):
 
     __properties__: dict[str, Property[Any]]

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/core/property/container.py

@@ -112,7 +112,7 @@ class Seq(ContainerProperty[T]):
 
     @classmethod
     def _is_seq_like(cls, value: Any) -> bool:
-        return (isinstance(value, Container | Sized | Iterable)
+        return (isinstance(value, (Container, Sized, Iterable))
                 and hasattr(value, "__getitem__") # NOTE: this is what makes it disallow set type
                 and not isinstance(value, Mapping))
 
@@ -291,7 +291,7 @@ class Tuple(ContainerProperty):
     def validate(self, value: Any, detail: bool = True) -> None:
         super().validate(value, detail)
 
-        if isinstance(value, tuple | list) and len(self.type_params) == len(value):
+        if isinstance(value, (tuple, list)) and len(self.type_params) == len(value):
             if all(type_param.is_valid(item) for type_param, item in zip(self.type_params, value)):
                 return
 

bokeh-3.9.0.dev4/src/bokeh/core/property/data_class.py

@@ -0,0 +1,69 @@
+#-----------------------------------------------------------------------------
+# Copyright (c) Anaconda, Inc., and Bokeh Contributors.
+# All rights reserved.
+#
+# The full license is in the file LICENSE.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+""" Provide the dataclass property.
+"""
+
+#-----------------------------------------------------------------------------
+# Boilerplate
+#-----------------------------------------------------------------------------
+from __future__ import annotations
+
+import logging # isort:skip
+log = logging.getLogger(__name__)
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Standard library imports
+from dataclasses import is_dataclass
+from typing import Any, TypeVar
+
+# Bokeh imports
+from .bases import Property
+
+#-----------------------------------------------------------------------------
+# Globals and constants
+#-----------------------------------------------------------------------------
+
+__all__ = (
+    'Dataclass',
+)
+
+T = TypeVar("T", bound=object)
+
+#-----------------------------------------------------------------------------
+# General API
+#-----------------------------------------------------------------------------
+
+class Dataclass(Property[T]):
+    """ Accept instance of dataclass.
+
+    This property only exists to support type validation, e.g. for "accepts"
+    clauses. It is not serializable itself, and is not useful to add to
+    Bokeh models directly.
+
+    """
+    def validate(self, value: Any, detail: bool = True) -> None:
+        super().validate(value, detail)
+        if is_dataclass(value) and not isinstance(value, type):
+            return
+
+        msg = "" if not detail else f"expected object to be dataclass, got {value!r}"
+        raise ValueError(msg)
+
+#-----------------------------------------------------------------------------
+# Dev API
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Private API
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/core/property/dataspec.py

@@ -607,7 +607,7 @@ class ColorSpec(DataSpec):
             True, if the value could be a color tuple
 
         """
-        return isinstance(val, tuple) and len(val) in (3, 4) and all(isinstance(v, float | int) for v in val)
+        return isinstance(val, tuple) and len(val) in (3, 4) and all(isinstance(v, (float, int)) for v in val)
 
     def prepare_value(self, cls, name, value):
         # Some explanation is in order. We want to accept tuples like

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/core/property/descriptors.py

@@ -480,7 +480,7 @@ class PropertyDescriptor(Generic[T]):
         from types import FunctionType
 
         from .instance import InstanceDefault
-        return isinstance(value, FunctionType | InstanceDefault)
+        return isinstance(value, (FunctionType, InstanceDefault))
 
     def _get(self, obj: HasProps) -> T:
         """ Internal implementation of instance attribute access for the

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/core/property/enum.py

@@ -65,7 +65,7 @@ class Enum(Either):
     def __init__(self, enum: int, *values: int, default: Init[int] = ..., help: str | None = ...) -> None: ...
 
     def __init__(self, enum: str | int | enums.Enumeration, *values: str | int, default: Init[str | int] = Intrinsic, help: str | None = None) -> None:
-        if isinstance(enum, str | int):
+        if isinstance(enum, (str, int)):
             self._enum = enums.enumeration(enum, *values)
         elif values:
             raise ValueError("unexpected enum values")

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/core/property/instance.py

@@ -69,7 +69,7 @@ class Object(Property[T]):
     _instance_type: type[T] | Callable[[], type[T]] | str
 
     def __init__(self, instance_type: type[T] | Callable[[], type[T]] | str, default: Init[T] = Undefined, help: str | None = None):
-        if not (isinstance(instance_type, type | str) or callable(instance_type)):
+        if not (isinstance(instance_type, (type, str)) or callable(instance_type)):
             raise ValueError(f"expected a type, fn() -> type, or string, got {instance_type}")
 
         if isinstance(instance_type, type):

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/core/property/visual.py

@@ -164,7 +164,7 @@ class Image(Property[str]):
         import numpy as np
         import PIL.Image
 
-        if isinstance(value, str | Path | PIL.Image.Image):
+        if isinstance(value, (str, Path, PIL.Image.Image)):
             return
 
         if isinstance(value, np.ndarray):
@@ -198,7 +198,7 @@ class Image(Property[str]):
             return data_image("svg+xml", "utf8", quote(value.read_text()))
 
         # tempfile doesn't implement IO interface (https://bugs.python.org/issue33762)
-        if isinstance(value, Path | BinaryIO | tempfile._TemporaryFileWrapper):
+        if isinstance(value, (Path, BinaryIO, tempfile._TemporaryFileWrapper)):
             value = PIL.Image.open(value)
 
         if isinstance(value, PIL.Image.Image):

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/core/property/visual.pyi

@@ -19,6 +19,8 @@ from typing import (
 import numpy as np
 import numpy.typing as npt
 
+import re # isort:skip
+
 if TYPE_CHECKING:
     import PIL.Image
 
@@ -30,6 +32,8 @@ from .bases import Property
 DashPatternType: TypeAlias = enums.DashPatternType | str | Sequence[int]
 DashPattern: TypeAlias = Property[DashPatternType]
 
+CSS_LENGTH_RE: re.Pattern
+
 ImageType: TypeAlias = str | Path | PIL.Image.Image | npt.NDArray[np.uint8]
 Image: TypeAlias = Property[ImageType]
 

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/core/property/wrappers.py

@@ -543,7 +543,7 @@ class PropertyValueColumnData(PropertyValueDict[Sequence[Any]]):
 
         for name, patch in patches.items():
             for ind, value in patch:
-                if isinstance(ind, int | slice):
+                if isinstance(ind, (int, slice)):
                     self[name][ind] = value
                 else:
                     shape = self[name][ind[0]][tuple(ind[1:])].shape

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/core/serialization.py

@@ -470,7 +470,7 @@ class Serializer:
         # avoid importing pandas here unless it is actually in use
         if uses_pandas(obj):
             import pandas as pd
-            if isinstance(obj, pd.Series | pd.Index | pd.api.extensions.ExtensionArray):
+            if isinstance(obj, (pd.Series, pd.Index, pd.api.extensions.ExtensionArray)):
                 return self._encode_ndarray(transform_series(obj))
             elif obj is pd.NA:
                 return None

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/document/document.py

@@ -196,7 +196,7 @@ class Document:
 
     @template.setter
     def template(self, template: Template) -> None:
-        if not isinstance(template, Template | str):
+        if not isinstance(template, (Template, str)):
             raise ValueError("document template must be Jinja2 template or a string")
         self._template = template
 

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/document/events.py

@@ -67,6 +67,7 @@ from typing import (
 
 # Bokeh imports
 from ..core.serialization import Serializable
+from ..util.dependencies import uses_pandas
 from .json import (
     ColumnDataChanged,
     ColumnsPatched,
@@ -515,9 +516,10 @@ class ColumnsStreamedEvent(DocumentPatchedEvent):
         self.attr = attr
 
 
-        import pandas as pd
-        if isinstance(data, pd.DataFrame):
-            data = {c: data[c] for c in data.columns}
+        if uses_pandas(data):
+            import pandas as pd
+            if isinstance(data, pd.DataFrame):
+                data = {c: data[c] for c in data.columns}
 
         self.data = data
         self.rollover = rollover

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/embed/bundle.py

@@ -445,7 +445,7 @@ def _use_mathjax(all_objs: set[HasProps]) -> bool:
     from ..models.glyphs import MathTextGlyph
     from ..models.text import MathText
 
-    return _any(all_objs, lambda obj: isinstance(obj, MathTextGlyph | MathText) or _model_requires_mathjax(obj)) or _ext_use_mathjax(all_objs)
+    return _any(all_objs, lambda obj: isinstance(obj, (MathTextGlyph, MathText)) or _model_requires_mathjax(obj)) or _ext_use_mathjax(all_objs)
 
 def _use_gl(all_objs: set[HasProps]) -> bool:
     ''' Whether a collection of Bokeh objects contains a plot requesting WebGL

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/embed/standalone.py

@@ -453,16 +453,16 @@ def _check_models_or_docs(models: ModelLike | ModelLikeCollection) -> ModelLikeC
     input_type_valid = False
 
     # Check for single item
-    if isinstance(models, Model | Document):
+    if isinstance(models, (Model, Document)):
         models = [models]
 
     # Check for sequence
-    if isinstance(models, Sequence) and all(isinstance(x, Model | Document) for x in models):
+    if isinstance(models, Sequence) and all(isinstance(x, (Model, Document)) for x in models):
         input_type_valid = True
 
     if isinstance(models, dict) and \
         all(isinstance(x, str) for x in models.keys()) and \
-        all(isinstance(x, Model | Document) for x in models.values()):
+        all(isinstance(x, (Model, Document)) for x in models.values()):
         input_type_valid = True
 
     if not input_type_valid:

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/embed/util.py

@@ -296,10 +296,10 @@ def standalone_docs_json_and_render_items(models: Model | Document | Sequence[Mo
     '''
 
     '''
-    if isinstance(models, Model | Document):
+    if isinstance(models, (Model, Document)):
         models = [models]
 
-    if not (isinstance(models, Sequence) and all(isinstance(x, Model | Document) for x in models)):
+    if not (isinstance(models, Sequence) and all(isinstance(x, (Model, Document)) for x in models)):
         raise ValueError("Expected a Model, Document, or Sequence of Models or Documents")
 
     if submodel_has_python_callbacks(models) and not suppress_callback_warning:

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/events.py

@@ -316,7 +316,7 @@ class ButtonClick(ModelEvent):
 
     def __init__(self, model: AbstractButton | None) -> None:
         from .models.widgets import AbstractButton, ToggleButtonGroup
-        if model is not None and not isinstance(model, AbstractButton | ToggleButtonGroup):
+        if model is not None and not isinstance(model, (AbstractButton, ToggleButtonGroup)):
             clsname = self.__class__.__name__
             raise ValueError(f"{clsname} event only applies to button and button group models")
         super().__init__(model=model)

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/io/export.py

@@ -435,10 +435,10 @@ def _write_collection(items: list[str], filename: PathLike | None, ext: str) ->
 def _log_console(driver: WebDriver) -> None:
     levels = {'WARNING', 'ERROR', 'SEVERE'}
     try:
-        logs = driver.get_log('browser')
+        driver_logs = driver.get_log('browser')
     except Exception:
         return
-    messages = [ log.get("message") for log in logs if log.get('level') in levels ]
+    messages = [driver_log.get("message") for driver_log in driver_logs if driver_log.get('level') in levels]
     if len(messages) > 0:
         log.warning("There were browser warnings and/or errors that may have affected your export")
         for message in messages:

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/layouts.py

@@ -330,7 +330,7 @@ def gridplot(
                 raise ValueError("Only UIElement and LayoutDOM items can be inserted into a grid")
 
     def merge(cls: type[Tool], group: list[Tool]) -> Tool | ToolProxy | None:
-        if issubclass(cls, SaveTool | CopyTool | ExamineTool | FullscreenTool):
+        if issubclass(cls, (SaveTool, CopyTool, ExamineTool, FullscreenTool)):
             return cls()
         else:
             return None

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/model/util.py

@@ -204,7 +204,7 @@ def visit_value_and_its_immediate_references(obj: Any, visitor: Callable[[Model]
     typ = type(obj)
     if typ in {int, float, str}:  # short circuit on common scalar types
         return
-    if typ is list or issubclass(typ, list | tuple):  # check common containers
+    if typ is list or issubclass(typ, (list, tuple)):  # check common containers
         for item in obj:
             visit_value_and_its_immediate_references(item, visitor)
     elif issubclass(typ, dict):

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/models/axes.pyi

@@ -36,6 +36,7 @@ from .formatters import (
     LogTickFormatter,
     MercatorTickFormatter,
     TickFormatter,
+    TimedeltaTickFormatter,
 )
 from .labeling import LabelingPolicy
 from .ranges import Factor
@@ -47,6 +48,7 @@ from .tickers import (
     LogTicker,
     MercatorTicker,
     Ticker,
+    TimedeltaTicker,
 )
 
 @abstract
@@ -132,3 +134,10 @@ class MercatorAxis(LinearAxis):
     ticker: MercatorTicker = ...
 
     formatter: MercatorTickFormatter = ...
+
+@dataclass
+class TimedeltaAxis(LinearAxis):
+
+    ticker: TimedeltaTicker = ...
+
+    formatter: TimedeltaTickFormatter = ...

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/models/formatters.pyi

@@ -110,3 +110,39 @@ class DatetimeTickFormatter(TickFormatter):
     context_which: ContextWhich = ...
 
     context_location: Location = ...
+
+@dataclass
+class TimedeltaTickFormatter(TickFormatter):
+
+    nanoseconds: str = ...
+
+    microseconds: str = ...
+
+    milliseconds: str = ...
+
+    seconds: str = ...
+
+    minsec: str = ...
+
+    minutes: str = ...
+
+    hourmin: str = ...
+
+    hours: str = ...
+
+    days: str = ...
+
+    strip_leading_zeros: bool | Sequence[ResolutionType] = ...
+
+    hide_repeats: bool = ...
+
+    context: str | TimedeltaTickFormatter | None = ...
+
+    context_which: ContextWhich = ...
+
+    context_location: Location = ...
+
+
+def CONTEXTUAL_DATETIME_FORMATTER() -> DatetimeTickFormatter: ...
+
+def CONTEXTUAL_TIMEDELTA_FORMATTER() -> TimedeltaTickFormatter: ...

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/models/glyphs.pyi

@@ -15,12 +15,12 @@ from .._specs import (
     DistanceSpec,
     FloatSpec,
     MarkerSpec,
-    NonNegative,
     NullDistanceSpec,
     NumberSpec,
     SizeSpec,
     StringSpec,
 )
+from .._types import NonNegative
 from ..core.enums import (
     DirectionType as Direction,
     HexTileOrientationType as HexTileOrientation,

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/models/mappers.pyi

@@ -14,7 +14,7 @@ from .._types import Color
 from ..core.enums import MarkerTypeType as MarkerType, PaletteType as Palette
 from ..core.has_props import abstract
 from ..core.property.visual import HatchPatternType as HatchPattern
-from .glyphs import Glyph
+from .glyph import Glyph
 from .ranges import FactorSeq
 from .renderers import GlyphRenderer
 from .transforms import Transform

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/models/nodes.pyi

@@ -13,7 +13,7 @@ from typing import ClassVar, Literal
 from .._types import CoordinateLike
 from ..core.has_props import abstract
 from ..model import Model
-from .glyphs import Glyph
+from .glyph import Glyph
 from .renderers import GlyphRenderer
 
 ImplicitTarget = Literal["viewport", "canvas", "plot", "frame", "parent"]

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/models/plots.py

@@ -23,15 +23,13 @@ log = logging.getLogger(__name__)
 # Standard library imports
 from contextlib import contextmanager
 from typing import (
+    TYPE_CHECKING,
     Any,
     Generator,
     Literal,
     overload,
 )
 
-# External imports
-import xyzservices
-
 # Bokeh imports
 from ..core.enums import (
     Location,
@@ -72,7 +70,7 @@ from ..model import Model
 from .annotations import Annotation, Legend, Title
 from .axes import Axis
 from .dom import HTML
-from .glyphs import Glyph
+from .glyph import Glyph
 from .grids import Grid
 from .layouts import GridCommon, LayoutDOM
 from .ranges import (
@@ -93,6 +91,9 @@ from .tiles import TileSource, WMTSTileSource
 from .tools import HoverTool, Tool, Toolbar
 from .ui import StyledElement
 
+if TYPE_CHECKING:
+    import xyzservices
+
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
@@ -406,6 +407,7 @@ class Plot(LayoutDOM):
 
         '''
         if not isinstance(tile_source, TileSource):
+            import xyzservices
 
             if isinstance(tile_source, xyzservices.TileProvider):
                 selected_provider = tile_source
@@ -479,14 +481,14 @@ class Plot(LayoutDOM):
 
         if self.x_scale is not None:
             for rng in x_ranges:
-                if isinstance(rng, DataRange1d | Range1d) and not isinstance(self.x_scale, LinearScale | LogScale):
+                if isinstance(rng, (DataRange1d, Range1d)) and not isinstance(self.x_scale, (LinearScale, LogScale)):
                     incompatible.append(f"incompatibility on x-dimension: {rng}, {self.x_scale}")
                 elif isinstance(rng, FactorRange) and not isinstance(self.x_scale, CategoricalScale):
                     incompatible.append(f"incompatibility on x-dimension: {rng}, {self.x_scale}")
 
         if self.y_scale is not None:
             for rng in y_ranges:
-                if isinstance(rng, DataRange1d | Range1d) and not isinstance(self.y_scale, LinearScale | LogScale):
+                if isinstance(rng, (DataRange1d, Range1d)) and not isinstance(self.y_scale, (LinearScale, LogScale)):
                     incompatible.append(f"incompatibility on y-dimension: {rng}, {self.y_scale}")
                 elif isinstance(rng, FactorRange) and not isinstance(self.y_scale, CategoricalScale):
                     incompatible.append(f"incompatibility on y-dimension: {rng}, {self.y_scale}")

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/models/plots.pyi

@@ -9,6 +9,7 @@
 from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import (
+    TYPE_CHECKING,
     Any,
     Generator,
     Sequence,
@@ -16,9 +17,6 @@ from typing import (
     overload,
 )
 
-# External imports
-import xyzservices
-
 # Bokeh imports
 from .._types import Readonly
 from ..core.enums import (
@@ -52,6 +50,9 @@ from .tiles import TileSource
 from .tools import HoverTool, Tool, Toolbar
 from .ui import StyledElement
 
+if TYPE_CHECKING:
+    import xyzservices
+
 GlyphType = TypeVar("GlyphType", bound=Glyph)
 
 class AxisListAttrSplat(list[Axis], Axis):

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/models/renderers/glyph_renderer.py

@@ -187,13 +187,8 @@ class GlyphRenderer(DataRenderer):
         '''
         from ...core.property.vectorization import Field
         from ..annotations import ColorBar
-        from ..glyphs import (
-            FillGlyph,
-            Image,
-            ImageStack,
-            LineGlyph,
-            TextGlyph,
-        )
+        from ..glyph import FillGlyph, LineGlyph, TextGlyph
+        from ..glyphs import Image, ImageStack
         from ..mappers import ColorMapper
 
         if isinstance(self.glyph, FillGlyph):
@@ -214,7 +209,7 @@ class GlyphRenderer(DataRenderer):
                 raise ValueError("expected text_color to be a field with a ColorMapper transform")
             return ColorBar(color_mapper=text_color.transform, **kwargs)
 
-        elif isinstance(self.glyph, Image | ImageStack):
+        elif isinstance(self.glyph, (Image, ImageStack)):
             return ColorBar(color_mapper=self.glyph.color_mapper, **kwargs)
 
         else:

{bokeh-3.9.0.dev2 → bokeh-3.9.0.dev4}/src/bokeh/models/renderers/glyph_renderer.pyi

@@ -17,7 +17,7 @@ from typing import (
 # Bokeh imports
 from ...core.enums import AutoType as Auto
 from ..annotations import ColorBar
-from ..glyphs import Glyph
+from ..glyph import Glyph
 from ..graphics import Decoration, Marking
 from ..sources import CDSView, DataSource
 from .renderer import DataRenderer