bokeh 4.0.0.dev6__tar.gz → 4.0.0.dev8__tar.gz

{bokeh-4.0.0.dev6 → bokeh-4.0.0.dev8}/MANIFEST.in

@@ -9,6 +9,14 @@ include src/bokeh/util/sampledata.json
 include src/bokeh/_sri.json
 include src/bokeh/LICENSE.txt
 include src/bokeh/py.typed
+# include generated notebook frontends
+include src/bokeh/jupyter/anywidget.js
+include src/bokeh/jupyter/logotype.svg
+include src/bokeh/jupyter/protocol.json
+graft src/bokeh/jupyter/jupyter-config
+graft src/bokeh/jupyter/labextension
+prune jupyter
+global-exclude *.py[cod]
 
 # start with an empty static/ dir
 prune src/bokeh/server/static

{bokeh-4.0.0.dev6/src/bokeh.egg-info → bokeh-4.0.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bokeh
-Version: 4.0.0.dev6
+Version: 4.0.0.dev8
 Summary: Interactive plots and applications in the browser from Python
 Author: Bokeh Team
 Author-email: info@bokeh.org
@@ -26,6 +26,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: JavaScript
 Classifier: Topic :: Office/Business
 Classifier: Topic :: Office/Business :: Financial
@@ -52,8 +53,11 @@ Requires-Dist: contourpy>=1.2; extra == "extra"
 Requires-Dist: pandas>=2.0; extra == "extra"
 Provides-Extra: export
 Requires-Dist: playwright>=1.49; extra == "export"
+Provides-Extra: notebook
+Requires-Dist: anywidget>=0.11; extra == "notebook"
+Requires-Dist: uvicorn[standard]>=0.30; sys_platform != "emscripten" and extra == "notebook"
 Provides-Extra: all
-Requires-Dist: bokeh[export,extra,sampledata]; extra == "all"
+Requires-Dist: bokeh[export,extra,notebook,sampledata]; extra == "all"
 Dynamic: license-file
 
 <picture>

{bokeh-4.0.0.dev6 → bokeh-4.0.0.dev8}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=77", "setuptools-git-versioning", "colorama"]
+requires = ["setuptools>=77", "setuptools-git-versioning", "colorama", "jupyter-builder>=1,<2"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -43,6 +43,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Programming Language :: JavaScript",
     "Topic :: Office/Business",
     "Topic :: Office/Business :: Financial",
@@ -64,8 +65,12 @@ extra = [
 export = [
     "playwright >=1.49",
 ]
+notebook = [
+    "anywidget >=0.11",
+    "uvicorn[standard] >=0.30; sys_platform != 'emscripten'",
+]
 all = [
-    "bokeh[sampledata,extra,export]",
+    "bokeh[sampledata,extra,export,notebook]",
 ]
 
 [project.urls]
@@ -76,6 +81,9 @@ repository = "https://github.com/bokeh/bokeh"
 [project.scripts]
 bokeh = "bokeh.__main__:main"
 
+[project.entry-points."nbconvert.exporters"]
+bokeh = "bokeh.io.jupyter_export:BokehHTMLExporter"
+
 [tool.setuptools.packages.find]
 where = ["src"]
 
@@ -134,6 +142,8 @@ filterwarnings = [
 [tool.coverage.run]
 source = ["src/bokeh"]
 omit = ["*/sampledata/*", "*/sphinxext/*", "*/tmp/tmp*.py"]
+patch = ["subprocess"]
+sigterm = true
 
 [tool.mypy]
 python_version = "3.12"

{bokeh-4.0.0.dev6 → bokeh-4.0.0.dev8}/setup.py

@@ -10,12 +10,12 @@ from __future__ import annotations
 import os, re, subprocess, sys, time
 from itertools import product
 from pathlib import Path
-from shutil import copy, copytree, rmtree
+from shutil import copy, copytree, rmtree, which
 from textwrap import indent
 from typing import NoReturn
 
 # External imports
-from setuptools import setup  # type: ignore[import]
+from setuptools import Distribution as SetuptoolsDistribution, setup  # type: ignore[import]
 from setuptools.command.build import build  # type: ignore[import]
 from setuptools.command.editable_wheel import editable_wheel  # type: ignore[import]
 from setuptools.command.sdist import sdist  # type: ignore[import]
@@ -41,6 +41,10 @@ BUILD_TSLIB = ROOT / 'bokehjs' / 'node_modules' / 'typescript' / 'lib'
 PKG_STATIC = SRC_ROOT / 'bokeh' / 'server' / 'static'
 PKG_JS = PKG_STATIC / 'js'
 PKG_TSLIB = PKG_STATIC / 'lib'
+JUPYTER_ROOT = SRC_ROOT / 'bokeh' / 'jupyter'
+JUPYTER_FRONTEND = ROOT / 'jupyter'
+JUPYTER_ANYWIDGET = JUPYTER_ROOT / 'anywidget.js'
+JUPYTER_LABEXTENSION = JUPYTER_ROOT / 'labextension'
 COMPONENTS = (
     "bokeh",
     "bokeh-widgets",
@@ -129,6 +133,46 @@ def build_or_install_bokehjs(packages: list[str]) -> None:
         raise ValueError(f"Unrecognized action {action!r}")
     print(f"Used {bright(yellow(kind))} BokehJS from {loc}\n")
 
+def build_jupyter() -> None:
+    print("\nBuilding the Jupyter frontend... ", end="")
+    if which("jupyter-builder") is None:
+        die(
+            f"{FAILED}\nERROR: 'jupyter-builder' is required to build the Jupyter frontend. "
+            "Install jupyter-builder>=1,<2 or build from a Bokeh source distribution.",
+        )
+    npm = "npm.cmd" if sys.platform == "win32" else "npm"
+    commands = (
+        [npm, "--prefix", str(JUPYTER_FRONTEND), "ci", "--no-progress"],
+        [npm, "--prefix", str(JUPYTER_FRONTEND), "run", "build"],
+    )
+    for command in commands:
+        try:
+            proc = subprocess.run(command, capture_output=True)
+        except OSError as e:
+            die(f"{FAILED}\nERROR: {command[0]!r} failed to execute:\n\n    {e}")
+        if proc.returncode != 0:
+            out = indent(proc.stdout.decode("utf-8", errors="replace"), "    ")
+            err = indent(proc.stderr.decode("utf-8", errors="replace"), "    ")
+            die(
+                f"{FAILED}\nERROR: {' '.join(command)!r} returned the following\n\n"
+                f"---- on stdout:\n{out}\n\n---- on stderr:\n{err}",
+            )
+    print(SUCCESS)
+
+def build_or_install_jupyter(data_files: list[tuple[str, list[str]]]) -> None:
+    action = os.environ.get("BOKEH_JUPYTER_ACTION", "build")
+    if PACKAGED:
+        kind, loc = "PACKAGED", "bokeh.jupyter"
+    elif action == "install":
+        kind, loc = "PREVIOUSLY BUILT", "src/bokeh/jupyter"
+    elif action == "build":
+        kind, loc = "NEWLY BUILT", "src/bokeh/jupyter"
+        build_jupyter()
+    else:
+        raise ValueError(f"Unrecognized action {action!r}")
+    data_files[:] = _jupyter_data_files(required=True)
+    print(f"Used {bright(yellow(kind))} Jupyter frontend from {loc}\n")
+
 def check_tags() -> None:
     if not PACKAGED:
         try:
@@ -138,6 +182,42 @@ def check_tags() -> None:
         except Exception:
             print(bright(yellow("!!! Could not check repo tags. Please ensure full tag history")))
 
+def _jupyter_data_files(*, required: bool) -> list[tuple[str, list[str]]]:
+    ''' Install the prebuilt extension where Jupyter discovers it automatically. '''
+    expected = [
+        JUPYTER_ANYWIDGET,
+        JUPYTER_LABEXTENSION / "package.json",
+        JUPYTER_LABEXTENSION / "install.json",
+        JUPYTER_ROOT / "jupyter-config" / "jupyter_server_config.d" / "bokeh-jupyter.json",
+    ]
+    missing = [str(path.relative_to(ROOT)) for path in expected if not path.is_file()]
+    if not any((JUPYTER_LABEXTENSION / "static").glob("remoteEntry.*.js")):
+        missing.append("src/bokeh/jupyter/labextension/static/remoteEntry.*.js")
+    if missing:
+        if required:
+            raise RuntimeError(
+                "The first-party Jupyter extension has not been built. Missing: " + ", ".join(missing),
+            )
+        return []
+
+    def source(path: Path) -> str:
+        return path.relative_to(ROOT).as_posix()
+
+    return [
+        (
+            "share/jupyter/labextensions/@bokeh/bokeh-jupyter",
+            [source(path) for path in (JUPYTER_LABEXTENSION / "package.json", JUPYTER_LABEXTENSION / "install.json")],
+        ),
+        (
+            "share/jupyter/labextensions/@bokeh/bokeh-jupyter/static",
+            [source(path) for path in sorted((JUPYTER_LABEXTENSION / "static").glob("*"))],
+        ),
+        (
+            "etc/jupyter/jupyter_server_config.d",
+            [source(JUPYTER_ROOT / "jupyter-config" / "jupyter_server_config.d" / "bokeh-jupyter.json")],
+        ),
+    ]
+
 def die(x: str) -> NoReturn:
     print(f"{x}\n")
     sys.exit(1)
@@ -164,22 +244,38 @@ BUILD_FAIL_MSG = f"""{FAILED}\nERROR: 'node make build' returned the following
 
 # --- Setuptools -------------------------------------------------------------
 
+class Distribution(SetuptoolsDistribution):  # type: ignore
+    def has_data(self) -> bool:
+        # setuptools' editable wheel checks this predicate instead of
+        # has_data_files() when deciding whether to run install_data.
+        return self.has_data_files()
+
 class Build(build):  # type: ignore
     def run(self) -> None:
         check_tags()
         build_or_install_bokehjs(self.distribution.packages)
+        build_or_install_jupyter(self.distribution.data_files)
+        built_jupyter = ROOT / "build" / "lib" / "bokeh" / "jupyter"
+        if built_jupyter.exists():
+            rmtree(built_jupyter)
         super().run()
 
 class EditableWheel(editable_wheel):  # type: ignore
     def run(self) -> None:
         check_tags()
         build_or_install_bokehjs(self.distribution.packages)
+        build_or_install_jupyter(self.distribution.data_files)
         super().run()
 
 class Sdist(sdist):  # type: ignore
     def run(self) -> None:
         check_tags()
         build_or_install_bokehjs(self.distribution.packages)
+        build_or_install_jupyter(self.distribution.data_files)
         super().run()
 
-setup(cmdclass={"build": Build, "editable_wheel": EditableWheel, "sdist": Sdist})
+setup(
+    cmdclass={"build": Build, "editable_wheel": EditableWheel, "sdist": Sdist},
+    data_files=_jupyter_data_files(required=PACKAGED),
+    distclass=Distribution,
+)

{bokeh-4.0.0.dev6 → bokeh-4.0.0.dev8}/src/bokeh/__init__.py

@@ -69,6 +69,9 @@ def license() -> None:
     with open(Path(__file__).parent / 'LICENSE.txt') as lic:
         print(lic.read())
 
+def _jupyter_labextension_paths() -> list[dict[str, str]]:
+    return [{"src": "jupyter/labextension", "dest": "@bokeh/bokeh-jupyter"}]
+
 #-----------------------------------------------------------------------------
 # Dev API
 #-----------------------------------------------------------------------------
@@ -107,3 +110,24 @@ def _configure_warnings() -> None:
 
 _configure_warnings()
 del _configure_warnings
+
+def _configure_marimo() -> None:
+    # marimo releases predating Bokeh 4 register a formatter that imports the
+    # removed output_notebook API and replaces show() with a static iframe.
+    # Disable only that formatter when marimo already owns the runtime. Its
+    # normal rich-display path then selects Bokeh's AnyWidget MIME bundle.
+    import sys
+    from importlib import import_module
+
+    if "marimo" not in sys.modules:
+        return
+    try:
+        formatters = import_module("marimo._output.formatters.formatters")
+    except ImportError:
+        return
+    factories = getattr(formatters, "THIRD_PARTY_FACTORIES", {})
+    if (factory := factories.get("bokeh")) is not None:
+        factory.register = lambda: None
+
+_configure_marimo()
+del _configure_marimo

{bokeh-4.0.0.dev6 → bokeh-4.0.0.dev8}/src/bokeh/application/handlers/code.py

@@ -81,9 +81,9 @@ class CodeHandler(Handler):
 
     # These functions, if present in the supplied code, will be monkey patched
     # to be no-ops, with a warning.
-    _io_functions = ['output_notebook', 'show', 'save']
+    _io_functions = ['show', 'save', 'serve']
 
-    _loggers: dict[str, Callable[..., None]]
+    _loggers: dict[str, Callable[..., Any]]
 
     _logger_text: ClassVar[str]
 
@@ -180,9 +180,10 @@ class CodeHandler(Handler):
     # Private methods ---------------------------------------------------------
 
     # subclasses must define self._logger_text
-    def _make_io_logger(self, name: str) -> Callable[..., None]:
-        def logger(*args: Any, **kwargs: Any) -> None:
+    def _make_io_logger(self, name: str) -> Callable[..., Any]:
+        def logger(*args: Any, **kwargs: Any) -> Any:
             log.info(self._logger_text, self._runner.path, name)
+            return _IgnoredNotebookApplication() if name == "serve" else None
         return logger
 
     # script is supposed to edit the doc not replace it
@@ -196,11 +197,15 @@ class CodeHandler(Handler):
 # Private API
 #-----------------------------------------------------------------------------
 
+class _IgnoredNotebookApplication:
+    def stop(self) -> None:
+        pass
+
 # monkeypatching is a little ugly, but in this case there's no reason any legitimate
 # code should be calling these functions, and we're only making a best effort to
 # warn people so no big deal if we fail.
 @contextmanager
-def _monkeypatch_io(loggers: dict[str, Callable[..., None]]) -> Generator[None]:
+def _monkeypatch_io(loggers: dict[str, Callable[..., Any]]) -> Generator[None]:
     import bokeh.io as io
     old: dict[str, Any] = {}
     for f in CodeHandler._io_functions:

{bokeh-4.0.0.dev6 → bokeh-4.0.0.dev8}/src/bokeh/application/handlers/code_runner.py

@@ -182,6 +182,8 @@ class CodeRunner:
             Module
 
         '''
+        from importlib.machinery import SourceFileLoader
+        from importlib.util import spec_from_loader
         from types import ModuleType
 
         self.reset_run_errors()
@@ -199,6 +201,10 @@ class CodeRunner:
             module.__package__ = module_name
             module.__path__ = [os.path.dirname(self._path)]
 
+        spec_name = f"{self._package.__name__}.{module_name}" if self._package else module_name
+        module.__loader__ = SourceFileLoader(spec_name, os.path.abspath(self._path))
+        module.__spec__ = spec_from_loader(spec_name, module.__loader__, is_package=hasattr(module, "__path__") and not self._package)
+
         return module
 
     def reset_run_errors(self) -> None:

{bokeh-4.0.0.dev6 → bokeh-4.0.0.dev8}/src/bokeh/command/subcommands/info.py

@@ -27,7 +27,8 @@ settings as part of the output:
     BokehJS static path   :  /opt/anaconda/envs/test/lib/python3.12/site-packages/bokeh/server/static
     node.js version       :  v20.12.2
     npm version           :  10.8.2
-    jupyter_bokeh version :  (not installed)
+    Jupyter protocol      :  2
+    Jupyter renderer      :  bundled
     Operating system      :  Linux-5.15.0-86-generic-x86_64-with-glibc2.35
 
     Set (non-default) Bokeh Settings:

bokeh-4.0.0.dev8/src/bokeh/core/_templates/notebook_info.html.jinja

@@ -0,0 +1,60 @@
+{# Renders diagnostic information about the active notebook integration. #}
+{% macro badge(text, tone) -%}
+{% set colors = {
+  "neutral": ("#4b5563", "#f1f3f4"),
+  "success": ("#137333", "#e6f4ea"),
+  "error": ("#b3261e", "#fce8e6"),
+}[tone] -%}
+<span style="display:inline-block;padding:2px 8px;border-radius:999px;white-space:nowrap;font-weight:600;color:{{ colors[0] }};background:{{ colors[1] }}">{{ text|e }}</span>
+{%- endmacro %}
+{% macro row(label, value, code=false) -%}
+<tr>
+  <th scope="row" style="width:34%;padding:7px 12px;text-align:left;vertical-align:top;border-top:1px solid var(--jp-border-color2,#e5e5e5);font-weight:600">{{ label|e }}</th>
+  <td style="padding:7px 12px;vertical-align:top;border-top:1px solid var(--jp-border-color2,#e5e5e5)">
+    {%- if code -%}
+    <code style="font:12px/1.45 ui-monospace,SFMono-Regular,Consolas,monospace;overflow-wrap:anywhere">{{ value|e }}</code>
+    {%- else -%}
+    {{ value|e }}
+    {%- endif -%}
+  </td>
+</tr>
+{%- endmacro %}
+<div class="bk-notebook-info" style="max-width:760px;overflow:hidden;border:1px solid var(--jp-border-color2,#d9d9d9);border-radius:8px;background:var(--jp-layout-color1,#fff);color:var(--jp-ui-font-color1,#222);font:13px/1.45 system-ui,sans-serif">
+  <div style="display:flex;align-items:center;gap:18px;padding:12px 14px;flex-wrap:wrap">
+    <div style="display:flex;align-items:center;padding:5px 9px;border-radius:6px;background:#fff">
+      {% if logo_data is not none -%}
+      <img alt="Bokeh" width="126" height="36" src="data:image/svg+xml;base64,{{ logo_data|e }}" style="display:block">
+      {%- else -%}
+      <strong style="font-size:24px;letter-spacing:-1px">Bokeh</strong>
+      {%- endif %}
+    </div>
+    <div>
+      <strong style="display:block;font-size:15px">Notebook integration</strong>
+      <span style="color:var(--jp-ui-font-color2,#666)">Bokeh {{ bokeh_version|e }}</span>
+    </div>
+    <div style="margin-left:auto" aria-label="Frontend integration">{{ badge(integration[0], integration[1]) }}</div>
+  </div>
+  <table style="width:100%;border-collapse:collapse">
+    <tr>
+      <th scope="row" style="width:34%;padding:7px 12px;text-align:left;vertical-align:top;border-top:1px solid var(--jp-border-color2,#e5e5e5);font-weight:600">Environment</th>
+      <td style="padding:7px 12px;vertical-align:top;border-top:1px solid var(--jp-border-color2,#e5e5e5)">
+        {{- badge(environment[0], environment[1]) }}
+        {%- if not extension_available %} <span style="color:#b3261e">Extension package unavailable</span>{% endif %}
+      </td>
+    </tr>
+    {% if resource_records or managed_applications -%}
+    <tr>
+      <th scope="row" style="width:34%;padding:7px 12px;text-align:left;vertical-align:top;border-top:1px solid var(--jp-border-color2,#e5e5e5);font-weight:600">Active state</th>
+      <td style="padding:7px 12px;vertical-align:top;border-top:1px solid var(--jp-border-color2,#e5e5e5)">{{ resource_records|e }} shared resource{{ "" if resource_records == 1 else "s" }} &middot; {{ managed_applications|e }} managed application{{ "" if managed_applications == 1 else "s" }}</td>
+    </tr>
+    {%- endif %}
+  </table>
+  <details style="border-top:1px solid var(--jp-border-color2,#e5e5e5)">
+    <summary style="padding:8px 12px;cursor:pointer;color:var(--jp-ui-font-color2,#666);font-weight:600">Technical details</summary>
+    <table style="width:100%;border-collapse:collapse">
+      {% for label, value in technical_rows -%}
+      {{ row(label, value, code=true) }}
+      {%- endfor %}
+    </table>
+  </details>
+</div>

bokeh-4.0.0.dev8/src/bokeh/core/_templates/portable_resources.js.jinja

@@ -0,0 +1,240 @@
+// Portable BokehJS resource owner for notebook hosts without the MIME extension.
+'use strict';
+(function(root) {
+  const resource_id = {{ resource_id|tojson }};
+  const expected_version = {{ bokeh_version|tojson }};
+  const requirements = {{ requirements|tojson }};
+  const dependencies = {{ dependencies|tojson }};
+  const load_timeout = {{ load_timeout|tojson }};
+  const artifacts = {{ artifacts|tojson }};
+
+  function notify(kind, detail = {}) {
+    root.dispatchEvent(new CustomEvent(`bokeh:resources-${kind}`, {
+      detail: {resource_id, ...detail},
+    }));
+  }
+
+  function report_failure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    for (const fallback of document.querySelectorAll("[data-bokeh-notebook-static-fallback][data-bokeh-resource-id]")) {
+      if (fallback.dataset.bokehResourceId !== resource_id)
+        continue;
+      fallback.dataset.bokehResourceError = message.slice(0, 300);
+      const title = fallback.querySelector("strong");
+      if (title != null)
+        title.textContent = "Bokeh resources failed to load";
+      const description = fallback.querySelector("p");
+      if (description != null)
+        description.textContent = message;
+    }
+  }
+
+  function owner_for(id) {
+    return [...document.head.querySelectorAll("meta[data-bokeh-notebook-resource]")]
+      .find((element) => element.dataset.bokehNotebookResource === id);
+  }
+
+  function wait_for_resource(id) {
+    const current = owner_for(id);
+    if (current?.dataset.bokehResourceState === "loaded")
+      return Promise.resolve();
+    if (current?.dataset.bokehResourceState === "failed")
+      return Promise.reject(new Error(current.dataset.bokehResourceError ?? `Resource dependency ${id} failed`));
+    return new Promise((resolve, reject) => {
+      let timer;
+      const cleanup = () => {
+        clearTimeout(timer);
+        root.removeEventListener("bokeh:resources-complete", complete);
+        root.removeEventListener("bokeh:resources-error", failed);
+      };
+      const complete = (event) => {
+        if (event.detail?.resource_id !== id)
+          return;
+        cleanup();
+        resolve();
+      };
+      const failed = (event) => {
+        if (event.detail?.resource_id !== id)
+          return;
+        cleanup();
+        reject(new Error(event.detail?.error?.message ?? `Resource dependency ${id} failed`));
+      };
+      root.addEventListener("bokeh:resources-complete", complete);
+      root.addEventListener("bokeh:resources-error", failed);
+      timer = setTimeout(() => {
+        cleanup();
+        reject(new Error(`Resource dependency ${id} was not published within ${load_timeout} ms`));
+      }, load_timeout);
+
+      // Close the small race between the initial state check and listener registration.
+      const latest = owner_for(id);
+      if (latest?.dataset.bokehResourceState === "loaded") {
+        cleanup();
+        resolve();
+      } else if (latest?.dataset.bokehResourceState === "failed") {
+        cleanup();
+        reject(new Error(latest.dataset.bokehResourceError ?? `Resource dependency ${id} failed`));
+      }
+    });
+  }
+
+  function wait_for_core(script) {
+    if (script.dataset.bokehResourceState === "loaded")
+      return Promise.resolve();
+    if (script.dataset.bokehResourceState === "failed")
+      return Promise.reject(new Error(`BokehJS core ${expected_version} failed to load`));
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        script.removeEventListener("load", loaded);
+        script.removeEventListener("error", failed);
+      };
+      const loaded = () => {
+        cleanup();
+        resolve();
+      };
+      const failed = () => {
+        cleanup();
+        reject(new Error(`BokehJS core ${expected_version} failed to load`));
+      };
+      script.addEventListener("load", loaded, {once: true});
+      script.addEventListener("error", failed, {once: true});
+      if (script.dataset.bokehResourceState === "loaded")
+        loaded();
+      else if (script.dataset.bokehResourceState === "failed")
+        failed();
+    });
+  }
+
+  function configure(element, artifact) {
+    if (artifact.integrity != null)
+      element.setAttribute("integrity", artifact.integrity);
+    if (artifact.crossorigin != null)
+      element.setAttribute("crossorigin", artifact.crossorigin);
+    if (artifact.nonce != null)
+      element.nonce = artifact.nonce;
+  }
+
+  async function load_core(artifact) {
+    if (root.Bokeh != null) {
+      if (root.Bokeh.version !== expected_version) {
+        throw new Error(
+          `BokehJS ${root.Bokeh.version ?? "unknown"} is already active. Refusing to load incompatible ${expected_version}`,
+        );
+      }
+      return;
+    }
+    if (artifact == null)
+      throw new Error(`BokehJS core ${expected_version} is unavailable`);
+
+    let script = [...document.head.querySelectorAll("script[data-bokeh-core-version]")]
+      .find((element) => element.dataset.bokehCoreVersion === expected_version);
+    if (script?.dataset.bokehResourceState === "failed") {
+      script.remove();
+      script = null;
+    }
+    if (script != null) {
+      await wait_for_core(script);
+    } else {
+      script = document.createElement("script");
+      script.type = artifact.module === true ? "module" : "text/javascript";
+      script.async = false;
+      script.dataset.bokehCoreVersion = expected_version;
+      script.dataset.bokehResourceState = "loading";
+      configure(script, artifact);
+      if (artifact.source === "url") {
+        script.src = artifact.value;
+        const ready = new Promise((resolve, reject) => {
+          script.onload = () => {
+            script.dataset.bokehResourceState = "loaded";
+            resolve();
+          };
+          script.onerror = (event) => {
+            script.dataset.bokehResourceState = "failed";
+            reject(new Error(`Failed to load ${artifact.value}`, {cause: event}));
+          };
+        });
+        document.head.append(script);
+        await ready;
+      } else {
+        script.textContent = artifact.value;
+        document.head.append(script);
+        script.dataset.bokehResourceState = "loaded";
+      }
+    }
+    if (root.Bokeh?.version !== expected_version)
+      throw new Error(`BokehJS core ${expected_version} loaded, but window.Bokeh reports ${root.Bokeh?.version ?? "unknown"}`);
+  }
+
+  function runtime_asset(artifact) {
+    return {
+      kind: artifact.kind === "js" ? "script" : "style",
+      ...(artifact.source === "url" ? {url: artifact.value} : {content: artifact.value}),
+      ...(artifact.integrity == null ? {} : {integrity: artifact.integrity}),
+      ...(artifact.crossorigin == null ? {} : {crossorigin: artifact.crossorigin}),
+      ...(artifact.nonce == null ? {} : {nonce: artifact.nonce}),
+      ...(artifact.module === true ? {module: true} : {}),
+    };
+  }
+
+  let owner = owner_for(resource_id);
+  if (owner?.dataset.bokehResourceState === "failed") {
+    owner.remove();
+    owner = null;
+  }
+  if (owner != null) {
+    void wait_for_resource(resource_id).then(
+      () => notify("complete", {artifact_ids: artifacts.map((artifact) => artifact.id)}),
+      (error) => notify("error", {error: {name: error.name, message: error.message}}),
+    );
+    return;
+  }
+
+  owner = document.createElement("meta");
+  owner.dataset.bokehNotebookResource = resource_id;
+  owner.setAttribute("data-bokeh-resource", "");
+  owner.dataset.bokehResourceState = "loading";
+  document.head.append(owner);
+
+  const load = async () => {
+    for (const dependency of dependencies)
+      await wait_for_resource(dependency);
+    const core = artifacts.find((artifact) => artifact.core === true);
+    await load_core(core);
+    // The split script-tag core publishes embed resources before the API
+    // bundle promotes mount helpers onto Bokeh. The all-in-one package also
+    // exposes the same loader at the top level.
+    const loader = root.Bokeh?.embed?.resource_loader ?? root.Bokeh?.resource_loader;
+    if (loader?.ensure == null)
+      throw new Error(`BokehJS ${expected_version} does not expose the common resource loader`);
+    const additive = artifacts.filter((artifact) => artifact !== core).map(runtime_asset);
+    await loader.ensure(requirements, {mode: "resolved", assets: additive, retry: true}, expected_version);
+  };
+
+  let timer;
+  const ready = Promise.race([
+    load(),
+    new Promise((_, reject) => timer = setTimeout(
+      () => reject(new Error(`Resource ${resource_id} did not load within ${load_timeout} ms`)),
+      load_timeout,
+    )),
+  ]);
+  ready.then(() => clearTimeout(timer), () => clearTimeout(timer));
+
+  void ready.then(() => {
+    owner.dataset.bokehResourceState = "loaded";
+    owner.dispatchEvent(new CustomEvent("bokeh:resource-loaded"));
+    notify("complete", {artifact_ids: artifacts.map((artifact) => artifact.id)});
+  }).catch((error) => {
+    owner.dataset.bokehResourceState = "failed";
+    owner.dataset.bokehResourceError = error instanceof Error ? error.message.slice(0, 300) : String(error).slice(0, 300);
+    report_failure(error);
+    // Release document-wide pending-resource waiters without reporting this
+    // record-scoped failure as their failure. Keep the failed record available
+    // for dependency diagnostics and retry it when it is requested again.
+    owner.removeAttribute("data-bokeh-resource");
+    owner.dispatchEvent(new Event("load"));
+    owner.dataset.bokehResourceState = "failed";
+    notify("error", {error: error instanceof Error ? {name: error.name, message: error.message, stack: error.stack} : String(error)});
+    console.error(`Bokeh: failed to load notebook resources ${resource_id}`, error);
+  });
+})(window);

{bokeh-4.0.0.dev6 → bokeh-4.0.0.dev8}/src/bokeh/core/_templates/try_run.js.jinja

@@ -16,6 +16,8 @@
         if (attempts > 100) {
           clearInterval(timer);
           console.log("Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing");
+          {% block missing_bokeh %}
+          {% endblock %}
         }
       }
     }, 10, root)