Source code for bokeh.embed.util

# Copyright (c) 2012 - 2024, Anaconda, Inc., and Bokeh Contributors.
# All rights reserved.
# The full license is in the file LICENSE.txt, distributed with this software.


# Boilerplate
from __future__ import annotations

import logging # isort:skip
log = logging.getLogger(__name__)

# Imports

# Standard library imports
import re
from contextlib import contextmanager
from typing import (
from weakref import WeakKeyDictionary

# Bokeh imports
from ..core.types import ID
from ..document.document import Document
from ..model import Model, collect_models
from ..settings import settings
from ..themes.theme import Theme
from ..util.dataclasses import dataclass, field
from ..util.serialization import (

    from ..document.document import DocJson

# Globals and constants

__all__ = (

# General API

# Dev API

class FromCurdoc:
    ''' This class merely provides a non-None default value for ``theme``
    arguments, since ``None`` itself is a meaningful value for users to pass.


def OutputDocumentFor(objs: Sequence[Model], apply_theme: Theme | type[FromCurdoc] | None = None,
        always_new: bool = False) -> Iterator[Document]:
    ''' Find or create a (possibly temporary) Document to use for serializing
    Bokeh content.

    Typical usage is similar to:

    .. code-block:: python

         with OutputDocumentFor(models):
            (docs_json, [render_item]) = standalone_docs_json_and_render_items(models)

    Inside the context manager, the models will be considered to be part of a single
    Document, with any theme specified, which can thus be serialized as a unit. Where
    possible, OutputDocumentFor attempts to use an existing Document. However, this is
    not possible in three cases:

    * If passed a series of models that have no Document at all, a new Document will
      be created, and all the models will be added as roots. After the context manager
      exits, the new Document will continue to be the models' document.

    * If passed a subset of Document.roots, then OutputDocumentFor temporarily "re-homes"
      the models in a new bare Document that is only available inside the context manager.

    * If passed a list of models that have different documents, then OutputDocumentFor
      temporarily "re-homes" the models in a new bare Document that is only available
      inside the context manager.

    OutputDocumentFor will also perfom document validation before yielding, if
    ``settings.perform_document_validation()`` is True.

        objs (seq[Model]) :
            a sequence of Models that will be serialized, and need a common document

        apply_theme (Theme or FromCurdoc or None, optional):
            Sets the theme for the doc while inside this context manager. (default: None)

            If None, use whatever theme is on the document that is found or created

            If FromCurdoc, use curdoc().theme, restoring any previous theme afterwards

            If a Theme instance, use that theme, restoring any previous theme afterwards

        always_new (bool, optional) :
            Always return a new document, even in cases where it is otherwise possible
            to use an existing document on models.


    # Note: Comms handling relies on the fact that the new_doc returned
    # has models with the same IDs as they were started with

    if not isinstance(objs, Sequence) or len(objs) == 0 or not all(isinstance(x, Model) for x in objs):
        raise ValueError("OutputDocumentFor expects a non-empty sequence of Models")

    def finish() -> None:

    docs = {obj.document for obj in objs if obj.document is not None}

    if always_new:
        def finish() -> None:  # noqa
        doc = _create_temp_doc(objs)
        if len(docs) == 0:
            doc = _new_doc()
            for model in objs:

        # handle a single shared document
        elif len(docs) == 1:
            doc = docs.pop()

            # we are not using all the roots, make a quick clone for outputting purposes
            if set(objs) != set(doc.roots):
                def finish() -> None:
                doc = _create_temp_doc(objs)

            # we are using all the roots of a single doc, just use doc as-is
            pass  # lgtm [py/unnecessary-pass]

        # models have mixed docs, just make a quick clone
            def finish():
            doc = _create_temp_doc(objs)

    if settings.perform_document_validation():

    _set_temp_theme(doc, apply_theme)
    yield doc


class RenderItem:
    def __init__(self, docid: ID | None = None, token: str | None = None, elementid: ID | None = None,
            roots: list[Model] | dict[Model, ID] | None = None, use_for_title: bool | None = None):

        if (docid is None and token is None) or (docid is not None and token is not None):
            raise ValueError("either docid or sessionid must be provided")

        if roots is None:
            roots = dict()
        elif isinstance(roots, list):
            roots = {root: make_globally_unique_id() for root in roots}

        self.docid = docid
        self.token = token
        self.elementid = elementid
        self.roots = RenderRoots(roots)
        self.use_for_title = use_for_title

    def to_json(self) -> dict[str, Any]:
        json: dict[str, Any] = {}

        if self.docid is not None:
            json["docid"] = self.docid
            json["token"] = self.token

        if self.elementid is not None:
            json["elementid"] = self.elementid

        if self.roots:
            json["roots"] = self.roots.to_json()
            json["root_ids"] = [ for root in self.roots]

        if self.use_for_title is not None:
            json["use_for_title"] = self.use_for_title

        return json

    def __eq__(self, other: Any) -> bool:
        if not isinstance(other, self.__class__):
            return False
            return self.to_json() == other.to_json()

[docs] @dataclass class RenderRoot: """ Encapsulate data needed for embedding a Bokeh document root. Values for ``name`` or ``tags`` are optional. They may be useful for querying a collection of roots to find a specific one to embed. """ #: A unique ID to use for the DOM element elementid: ID #: The Bokeh model ID for this root id: ID = field(compare=False) #: An optional user-supplied name for this root name: str | None = field(default="", compare=False) #: A list of any user-supplied tag values for this root tags: list[Any] = field(default_factory=list, compare=False) def __post_init__(self): # is nullable, and field() won't enforce the default when name=None = or ""
class RenderRoots: def __init__(self, roots: dict[Model, ID]) -> None: self._roots = roots def __iter__(self) -> Iterator[RenderRoot]: for i in range(0, len(self)): yield self[i] def __len__(self): return len(self._roots.items()) def __getitem__(self, key: int | str) -> RenderRoot: if isinstance(key, int): (root, elementid) = list(self._roots.items())[key] else: for root, elementid in self._roots.items(): if == key: break else: raise ValueError(f"root with {key!r} name not found") return RenderRoot(elementid,,, root.tags) def __getattr__(self, key: str) -> RenderRoot: return self.__getitem__(key) def to_json(self) -> dict[ID, ID]: return { elementid for root, elementid in self._roots.items()} def __repr__(self) -> str: return repr(self._roots) def standalone_docs_json(models: Sequence[Model | Document]) -> dict[ID, DocJson]: ''' ''' docs_json, _ = standalone_docs_json_and_render_items(models) return docs_json def standalone_docs_json_and_render_items(models: Model | Document | Sequence[Model | Document], *, suppress_callback_warning: bool = False) -> tuple[dict[ID, DocJson], list[RenderItem]]: ''' ''' if isinstance(models, (Model, Document)): models = [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: log.warning(_CALLBACKS_WARNING) docs: dict[Document, tuple[ID, dict[Model, ID]]] = {} for model_or_doc in models: if isinstance(model_or_doc, Document): model = None doc = model_or_doc else: model = model_or_doc doc = model.document if doc is None: raise ValueError("A Bokeh Model must be part of a Document to render as standalone content") if doc not in docs: docs[doc] = (make_globally_unique_id(), dict()) (docid, roots) = docs[doc] if model is not None: roots[model] = make_globally_unique_css_safe_id() else: for model in doc.roots: roots[model] = make_globally_unique_css_safe_id() docs_json: dict[ID, DocJson] = {} for doc, (docid, _) in docs.items(): docs_json[docid] = doc.to_json(deferred=False) render_items: list[RenderItem] = [] for _, (docid, roots) in docs.items(): render_items.append(RenderItem(docid, roots=roots)) return (docs_json, render_items) def submodel_has_python_callbacks(models: Sequence[Model | Document]) -> bool: ''' Traverses submodels to check for Python (event) callbacks ''' has_python_callback = False for model in collect_models(models): if len(model._callbacks) > 0 or len(model._event_callbacks) > 0: has_python_callback = True break return has_python_callback def is_tex_string(text: str) -> bool: ''' Whether a string begins and ends with MathJax default delimiters Args: text (str): String to check Returns: bool: True if string begins and ends with delimiters, False if not ''' dollars = r"^\$\$.*?\$\$$" braces = r"^\\\[.*?\\\]$" parens = r"^\\\(.*?\\\)$" pat = re.compile(f"{dollars}|{braces}|{parens}", flags=re.S) return pat.match(text) is not None def contains_tex_string(text: str) -> bool: ''' Whether a string contains any pair of MathJax default delimiters Args: text (str): String to check Returns: bool: True if string contains delimiters, False if not ''' # these are non-greedy dollars = r"\$\$.*?\$\$" braces = r"\\\[.*?\\\]" parens = r"\\\(.*?\\\)" pat = re.compile(f"{dollars}|{braces}|{parens}", flags=re.S) return is not None #----------------------------------------------------------------------------- # Private API #----------------------------------------------------------------------------- _CALLBACKS_WARNING = """ You are generating standalone HTML/JS output, but trying to use real Python callbacks (i.e. with on_change or on_event). This combination cannot work. Only JavaScript callbacks may be used with standalone output. For more information on JavaScript callbacks with Bokeh, see: Alternatively, to use real Python callbacks, a Bokeh server application may be used. For more information on building and running Bokeh applications, see: """ def _new_doc() -> Document: # TODO: embed APIs need to actually respect the existing document's # configuration, but for now this is better than nothing. from import curdoc doc = Document() callbacks = curdoc().callbacks._js_event_callbacks doc.callbacks._js_event_callbacks.update(callbacks) return doc def _create_temp_doc(models: Sequence[Model]) -> Document: doc = _new_doc() for m in models: doc.models[] = m m._temp_document = doc for ref in m.references(): doc.models[] = ref ref._temp_document = doc doc._roots = list(models) return doc def _dispose_temp_doc(models: Sequence[Model]) -> None: for m in models: m._temp_document = None for ref in m.references(): ref._temp_document = None _themes: WeakKeyDictionary[Document, Theme] = WeakKeyDictionary() def _set_temp_theme(doc: Document, apply_theme: Theme | type[FromCurdoc] | None) -> None: _themes[doc] = doc.theme if apply_theme is FromCurdoc: from import curdoc doc.theme = curdoc().theme elif isinstance(apply_theme, Theme): doc.theme = apply_theme def _unset_temp_theme(doc: Document) -> None: if doc not in _themes: return doc.theme = _themes[doc] del _themes[doc] #----------------------------------------------------------------------------- # Code #-----------------------------------------------------------------------------