Add files using upload-large-folder tool

.gitattributes

@@ -969,3 +969,4 @@ parrot/lib/python3.10/html/__pycache__/entities.cpython-310.pyc filter=lfs diff=
 vllm/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_sql.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_loc.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/pandas/tests/tools/__pycache__/test_to_datetime.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+videollama2/lib/python3.10/site-packages/fontTools/feaLib/lexer.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

videollama2/lib/python3.10/site-packages/altair/utils/_importers.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from importlib.metadata import version as importlib_version
+from typing import TYPE_CHECKING
+
+from packaging.version import Version
+
+if TYPE_CHECKING:
+    from types import ModuleType
+
+
+def import_vegafusion() -> ModuleType:
+    min_version = "1.5.0"
+    try:
+        version = importlib_version("vegafusion")
+        embed_version = importlib_version("vegafusion-python-embed")
+        if version != embed_version or Version(version) < Version(min_version):
+            msg = (
+                "The versions of the vegafusion and vegafusion-python-embed packages must match\n"
+                f"and must be version {min_version} or greater.\n"
+                f"Found:\n"
+                f" - vegafusion=={version}\n"
+                f" - vegafusion-python-embed=={embed_version}\n"
+            )
+            raise RuntimeError(msg)
+        import vegafusion as vf  # type: ignore
+
+        return vf
+    except ImportError as err:
+        msg = (
+            'The "vegafusion" data transformer and chart.transformed_data feature requires\n'
+            f"version {min_version} or greater of the 'vegafusion-python-embed' and 'vegafusion' packages.\n"
+            "These can be installed with pip using:\n"
+            f'    pip install "vegafusion[embed]>={min_version}"\n'
+            "Or with conda using:\n"
+            f'    conda install -c conda-forge "vegafusion-python-embed>={min_version}" '
+            f'"vegafusion>={min_version}"\n\n'
+            f"ImportError: {err.args[0]}"
+        )
+        raise ImportError(msg) from err
+
+
+def import_vl_convert() -> ModuleType:
+    min_version = "1.6.0"
+    try:
+        version = importlib_version("vl-convert-python")
+        if Version(version) < Version(min_version):
+            msg = (
+                f"The vl-convert-python package must be version {min_version} or greater. "
+                f"Found version {version}"
+            )
+            raise RuntimeError(msg)
+        import vl_convert as vlc
+
+        return vlc
+    except ImportError as err:
+        msg = (
+            f"The vl-convert Vega-Lite compiler and file export feature requires\n"
+            f"version {min_version} or greater of the 'vl-convert-python' package. \n"
+            f"This can be installed with pip using:\n"
+            f'   pip install "vl-convert-python>={min_version}"\n'
+            "or conda:\n"
+            f'   conda install -c conda-forge "vl-convert-python>={min_version}"\n\n'
+            f"ImportError: {err.args[0]}"
+        )
+        raise ImportError(msg) from err
+
+
+def vl_version_for_vl_convert() -> str:
+    from altair.vegalite import SCHEMA_VERSION
+
+    # Compute VlConvert's vl_version string (of the form 'v5_2')
+    # from SCHEMA_VERSION (of the form 'v5.2.0')
+    return "_".join(SCHEMA_VERSION.split(".")[:2])
+
+
+def import_pyarrow_interchange() -> ModuleType:
+    min_version = "11.0.0"
+    try:
+        version = importlib_version("pyarrow")
+
+        if Version(version) < Version(min_version):
+            msg = (
+                f"The pyarrow package must be version {min_version} or greater. "
+                f"Found version {version}"
+            )
+            raise RuntimeError(msg)
+        import pyarrow.interchange as pi
+
+        return pi
+    except ImportError as err:
+        msg = (
+            f"Usage of the DataFrame Interchange Protocol requires\n"
+            f"version {min_version} or greater of the pyarrow package. \n"
+            f"This can be installed with pip using:\n"
+            f'   pip install "pyarrow>={min_version}"\n'
+            "or conda:\n"
+            f'   conda install -c conda-forge "pyarrow>={min_version}"\n\n'
+            f"ImportError: {err.args[0]}"
+        )
+        raise ImportError(msg) from err
+
+
+def pyarrow_available() -> bool:
+    try:
+        import_pyarrow_interchange()
+        return True
+    except (ImportError, RuntimeError):
+        return False

videollama2/lib/python3.10/site-packages/altair/utils/_show.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Iterable
+
+
+def open_html_in_browser(
+    html: str | bytes,
+    using: str | Iterable[str] | None = None,
+    port: int | None = None,
+) -> None:
+    """
+    Display an html document in a web browser without creating a temp file.
+
+    Instantiates a simple http server and uses the webbrowser module to
+    open the server's URL
+
+    Parameters
+    ----------
+    html: str
+        HTML string to display
+    using: str or iterable of str
+        Name of the web browser to open (e.g. "chrome", "firefox", etc.).
+        If an iterable, choose the first browser available on the system.
+        If none, choose the system default browser.
+    port: int
+        Port to use. Defaults to a random port
+    """
+    # Encode html to bytes
+    html_bytes = html.encode("utf8") if isinstance(html, str) else html
+
+    browser = None
+
+    if using is None:
+        browser = webbrowser.get(None)
+    else:
+        # normalize using to an iterable
+        if isinstance(using, str):
+            using = [using]
+
+        for browser_key in using:
+            try:
+                browser = webbrowser.get(browser_key)
+                if browser is not None:
+                    break
+            except webbrowser.Error:
+                pass
+
+        if browser is None:
+            raise ValueError("Failed to locate a browser with name in " + str(using))
+
+    class OneShotRequestHandler(BaseHTTPRequestHandler):
+        def do_GET(self) -> None:
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+
+            bufferSize = 1024 * 1024
+            for i in range(0, len(html_bytes), bufferSize):
+                self.wfile.write(html_bytes[i : i + bufferSize])
+
+        def log_message(self, format, *args):
+            # Silence stderr logging
+            pass
+
+    # Use specified port if provided, otherwise choose a random port (port value of 0)
+    server = HTTPServer(
+        ("127.0.0.1", port if port is not None else 0), OneShotRequestHandler
+    )
+    browser.open(f"http://127.0.0.1:{server.server_port}")
+    server.handle_request()

videollama2/lib/python3.10/site-packages/altair/utils/_vegafusion_data.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import uuid
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Final,
+    MutableMapping,
+    TypedDict,
+    Union,
+    overload,
+)
+from weakref import WeakValueDictionary
+
+from altair.utils._importers import import_vegafusion
+from altair.utils.core import DataFrameLike
+from altair.utils.data import (
+    DataType,
+    MaxRowsError,
+    SupportsGeoInterface,
+    ToValuesReturnType,
+)
+from altair.vegalite.data import default_data_transformer
+
+if TYPE_CHECKING:
+    from narwhals.typing import IntoDataFrame
+
+    from vegafusion.runtime import ChartState  # type: ignore
+
+# Temporary storage for dataframes that have been extracted
+# from charts by the vegafusion data transformer. Use a WeakValueDictionary
+# rather than a dict so that the Python interpreter is free to garbage
+# collect the stored DataFrames.
+extracted_inline_tables: MutableMapping[str, DataFrameLike] = WeakValueDictionary()
+
+# Special URL prefix that VegaFusion uses to denote that a
+# dataset in a Vega spec corresponds to an entry in the `inline_datasets`
+# kwarg of vf.runtime.pre_transform_spec().
+VEGAFUSION_PREFIX: Final = "vegafusion+dataset://"
+
+
+class _ToVegaFusionReturnUrlDict(TypedDict):
+    url: str
+
+
+_VegaFusionReturnType = Union[_ToVegaFusionReturnUrlDict, ToValuesReturnType]
+
+
+@overload
+def vegafusion_data_transformer(
+    data: None = ..., max_rows: int = ...
+) -> Callable[..., Any]: ...
+
+
+@overload
+def vegafusion_data_transformer(
+    data: DataFrameLike, max_rows: int = ...
+) -> ToValuesReturnType: ...
+
+
+@overload
+def vegafusion_data_transformer(
+    data: dict | IntoDataFrame | SupportsGeoInterface, max_rows: int = ...
+) -> _VegaFusionReturnType: ...
+
+
+def vegafusion_data_transformer(
+    data: DataType | None = None, max_rows: int = 100000
+) -> Callable[..., Any] | _VegaFusionReturnType:
+    """VegaFusion Data Transformer."""
+    if data is None:
+        return vegafusion_data_transformer
+    elif isinstance(data, DataFrameLike) and not isinstance(data, SupportsGeoInterface):
+        table_name = f"table_{uuid.uuid4()}".replace("-", "_")
+        extracted_inline_tables[table_name] = data
+        return {"url": VEGAFUSION_PREFIX + table_name}
+    else:
+        # Use default transformer for geo interface objects
+        # # (e.g. a geopandas GeoDataFrame)
+        # Or if we don't recognize data type
+        return default_data_transformer(data)
+
+
+def get_inline_table_names(vega_spec: dict[str, Any]) -> set[str]:
+    """
+    Get a set of the inline datasets names in the provided Vega spec.
+
+    Inline datasets are encoded as URLs that start with the table://
+    prefix.
+
+    Parameters
+    ----------
+    vega_spec: dict
+        A Vega specification dict
+
+    Returns
+    -------
+    set of str
+        Set of the names of the inline datasets that are referenced
+        in the specification.
+
+    Examples
+    --------
+    >>> spec = {
+    ...     "data": [
+    ...         {"name": "foo", "url": "https://path/to/file.csv"},
+    ...         {"name": "bar", "url": "vegafusion+dataset://inline_dataset_123"},
+    ...     ]
+    ... }
+    >>> get_inline_table_names(spec)
+    {'inline_dataset_123'}
+    """
+    table_names = set()
+
+    # Process datasets
+    for data in vega_spec.get("data", []):
+        url = data.get("url", "")
+        if url.startswith(VEGAFUSION_PREFIX):
+            name = url[len(VEGAFUSION_PREFIX) :]
+            table_names.add(name)
+
+    # Recursively process child marks, which may have their own datasets
+    for mark in vega_spec.get("marks", []):
+        table_names.update(get_inline_table_names(mark))
+
+    return table_names
+
+
+def get_inline_tables(vega_spec: dict[str, Any]) -> dict[str, DataFrameLike]:
+    """
+    Get the inline tables referenced by a Vega specification.
+
+    Note: This function should only be called on a Vega spec that corresponds
+    to a chart that was processed by the vegafusion_data_transformer.
+    Furthermore, this function may only be called once per spec because
+    the returned dataframes are deleted from internal storage.
+
+    Parameters
+    ----------
+    vega_spec: dict
+        A Vega specification dict
+
+    Returns
+    -------
+    dict from str to dataframe
+        dict from inline dataset name to dataframe object
+    """
+    inline_names = get_inline_table_names(vega_spec)
+    # exclude named dataset that was provided by the user,
+    # or dataframes that have been deleted.
+    table_names = inline_names.intersection(extracted_inline_tables)
+    return {k: extracted_inline_tables.pop(k) for k in table_names}
+
+
+def compile_to_vegafusion_chart_state(
+    vegalite_spec: dict[str, Any], local_tz: str
+) -> ChartState:
+    """
+    Compile a Vega-Lite spec to a VegaFusion ChartState.
+
+    Note: This function should only be called on a Vega-Lite spec
+    that was generated with the "vegafusion" data transformer enabled.
+    In particular, this spec may contain references to extract datasets
+    using table:// prefixed URLs.
+
+    Parameters
+    ----------
+    vegalite_spec: dict
+        A Vega-Lite spec that was generated from an Altair chart with
+        the "vegafusion" data transformer enabled
+    local_tz: str
+        Local timezone name (e.g. 'America/New_York')
+
+    Returns
+    -------
+    ChartState
+        A VegaFusion ChartState object
+    """
+    # Local import to avoid circular ImportError
+    from altair import data_transformers, vegalite_compilers
+
+    vf = import_vegafusion()
+
+    # Compile Vega-Lite spec to Vega
+    compiler = vegalite_compilers.get()
+    if compiler is None:
+        msg = "No active vega-lite compiler plugin found"
+        raise ValueError(msg)
+
+    vega_spec = compiler(vegalite_spec)
+
+    # Retrieve dict of inline tables referenced by the spec
+    inline_tables = get_inline_tables(vega_spec)
+
+    # Pre-evaluate transforms in vega spec with vegafusion
+    row_limit = data_transformers.options.get("max_rows", None)
+
+    chart_state = vf.runtime.new_chart_state(
+        vega_spec,
+        local_tz=local_tz,
+        inline_datasets=inline_tables,
+        row_limit=row_limit,
+    )
+
+    # Check from row limit warning and convert to MaxRowsError
+    handle_row_limit_exceeded(row_limit, chart_state.get_warnings())
+
+    return chart_state
+
+
+def compile_with_vegafusion(vegalite_spec: dict[str, Any]) -> dict[str, Any]:
+    """
+    Compile a Vega-Lite spec to Vega and pre-transform with VegaFusion.
+
+    Note: This function should only be called on a Vega-Lite spec
+    that was generated with the "vegafusion" data transformer enabled.
+    In particular, this spec may contain references to extract datasets
+    using table:// prefixed URLs.
+
+    Parameters
+    ----------
+    vegalite_spec: dict
+        A Vega-Lite spec that was generated from an Altair chart with
+        the "vegafusion" data transformer enabled
+
+    Returns
+    -------
+    dict
+        A Vega spec that has been pre-transformed by VegaFusion
+    """
+    # Local import to avoid circular ImportError
+    from altair import data_transformers, vegalite_compilers
+
+    vf = import_vegafusion()
+
+    # Compile Vega-Lite spec to Vega
+    compiler = vegalite_compilers.get()
+    if compiler is None:
+        msg = "No active vega-lite compiler plugin found"
+        raise ValueError(msg)
+
+    vega_spec = compiler(vegalite_spec)
+
+    # Retrieve dict of inline tables referenced by the spec
+    inline_tables = get_inline_tables(vega_spec)
+
+    # Pre-evaluate transforms in vega spec with vegafusion
+    row_limit = data_transformers.options.get("max_rows", None)
+    transformed_vega_spec, warnings = vf.runtime.pre_transform_spec(
+        vega_spec,
+        vf.get_local_tz(),
+        inline_datasets=inline_tables,
+        row_limit=row_limit,
+    )
+
+    # Check from row limit warning and convert to MaxRowsError
+    handle_row_limit_exceeded(row_limit, warnings)
+
+    return transformed_vega_spec
+
+
+def handle_row_limit_exceeded(row_limit: int, warnings: list):
+    for warning in warnings:
+        if warning.get("type") == "RowLimitExceeded":
+            msg = (
+                "The number of dataset rows after filtering and aggregation exceeds\n"
+                f"the current limit of {row_limit}. Try adding an aggregation to reduce\n"
+                "the size of the dataset that must be loaded into the browser. Or, disable\n"
+                "the limit by calling alt.data_transformers.disable_max_rows(). Note that\n"
+                "disabling this limit may cause the browser to freeze or crash."
+            )
+            raise MaxRowsError(msg)
+
+
+def using_vegafusion() -> bool:
+    """Check whether the vegafusion data transformer is enabled."""
+    # Local import to avoid circular ImportError
+    from altair import data_transformers
+
+    return data_transformers.active == "vegafusion"

videollama2/lib/python3.10/site-packages/altair/utils/display.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import json
+import pkgutil
+import textwrap
+import uuid
+from typing import Any, Callable, Dict, Tuple, Union
+from typing_extensions import TypeAlias
+
+from ._vegafusion_data import compile_with_vegafusion, using_vegafusion
+from .mimebundle import spec_to_mimebundle
+from .plugin_registry import PluginEnabler, PluginRegistry
+from .schemapi import validate_jsonschema
+
+# ==============================================================================
+# Renderer registry
+# ==============================================================================
+# MimeBundleType needs to be the same as what are acceptable return values
+# for _repr_mimebundle_,
+# see https://ipython.readthedocs.io/en/stable/config/integrating.html#MyObject._repr_mimebundle_
+MimeBundleDataType: TypeAlias = Dict[str, Any]
+MimeBundleMetaDataType: TypeAlias = Dict[str, Any]
+MimeBundleType: TypeAlias = Union[
+    MimeBundleDataType, Tuple[MimeBundleDataType, MimeBundleMetaDataType]
+]
+RendererType: TypeAlias = Callable[..., MimeBundleType]
+# Subtype of MimeBundleType as more specific in the values of the dictionaries
+
+DefaultRendererReturnType: TypeAlias = Tuple[
+    Dict[str, Union[str, Dict[str, Any]]], Dict[str, Dict[str, Any]]
+]
+
+
+class RendererRegistry(PluginRegistry[RendererType, MimeBundleType]):
+    entrypoint_err_messages = {
+        "notebook": textwrap.dedent(
+            """
+            To use the 'notebook' renderer, you must install the vega package
+            and the associated Jupyter extension.
+            See https://altair-viz.github.io/getting_started/installation.html
+            for more information.
+            """
+        ),
+    }
+
+    def set_embed_options(
+        self,
+        defaultStyle: bool | str | None = None,
+        renderer: str | None = None,
+        width: int | None = None,
+        height: int | None = None,
+        padding: int | None = None,
+        scaleFactor: float | None = None,
+        actions: bool | dict[str, bool] | None = None,
+        format_locale: str | dict | None = None,
+        time_format_locale: str | dict | None = None,
+        **kwargs,
+    ) -> PluginEnabler:
+        """
+        Set options for embeddings of Vega & Vega-Lite charts.
+
+        Options are fully documented at https://github.com/vega/vega-embed.
+        Similar to the `enable()` method, this can be used as either
+        a persistent global switch, or as a temporary local setting using
+        a context manager (i.e. a `with` statement).
+
+        Parameters
+        ----------
+        defaultStyle : bool or string
+            Specify a default stylesheet for embed actions.
+        renderer : string
+            The renderer to use for the view. One of "canvas" (default) or "svg"
+        width : integer
+            The view width in pixels
+        height : integer
+            The view height in pixels
+        padding : integer
+            The view padding in pixels
+        scaleFactor : number
+            The number by which to multiply the width and height (default 1)
+            of an exported PNG or SVG image.
+        actions : bool or dict
+            Determines if action links ("Export as PNG/SVG", "View Source",
+            "View Vega" (only for Vega-Lite), "Open in Vega Editor") are
+            included with the embedded view. If the value is true, all action
+            links will be shown and none if the value is false. This property
+            can take a key-value mapping object that maps keys (export, source,
+            compiled, editor) to boolean values for determining if
+            each action link should be shown.
+        format_locale : str or dict
+            d3-format locale name or dictionary. Defaults to "en-US" for United States English.
+            See https://github.com/d3/d3-format/tree/main/locale for available names and example
+            definitions.
+        time_format_locale : str or dict
+            d3-time-format locale name or dictionary. Defaults to "en-US" for United States English.
+            See https://github.com/d3/d3-time-format/tree/main/locale for available names and example
+            definitions.
+        **kwargs :
+            Additional options are passed directly to embed options.
+        """
+        options: dict[str, bool | str | float | dict[str, bool] | None] = {
+            "defaultStyle": defaultStyle,
+            "renderer": renderer,
+            "width": width,
+            "height": height,
+            "padding": padding,
+            "scaleFactor": scaleFactor,
+            "actions": actions,
+            "formatLocale": format_locale,
+            "timeFormatLocale": time_format_locale,
+        }
+        kwargs.update({key: val for key, val in options.items() if val is not None})
+        return self.enable(None, embed_options=kwargs)
+
+
+# ==============================================================================
+# VegaLite v1/v2 renderer logic
+# ==============================================================================
+
+
+class Displayable:
+    """
+    A base display class for VegaLite v1/v2.
+
+    This class takes a VegaLite v1/v2 spec and does the following:
+
+    1. Optionally validates the spec against a schema.
+    2. Uses the RendererPlugin to grab a renderer and call it when the
+       IPython/Jupyter display method (_repr_mimebundle_) is called.
+
+    The spec passed to this class must be fully schema compliant and already
+    have the data portion of the spec fully processed and ready to serialize.
+    In practice, this means, the data portion of the spec should have been passed
+    through appropriate data model transformers.
+    """
+
+    renderers: RendererRegistry | None = None
+    schema_path = ("altair", "")
+
+    def __init__(self, spec: dict[str, Any], validate: bool = False) -> None:
+        self.spec = spec
+        self.validate = validate
+        self._validate()
+
+    def _validate(self) -> None:
+        """Validate the spec against the schema."""
+        data = pkgutil.get_data(*self.schema_path)
+        assert data is not None
+        schema_dict: dict[str, Any] = json.loads(data.decode("utf-8"))
+        validate_jsonschema(
+            self.spec,
+            schema_dict,
+        )
+
+    def _repr_mimebundle_(
+        self, include: Any = None, exclude: Any = None
+    ) -> MimeBundleType:
+        """Return a MIME bundle for display in Jupyter frontends."""
+        if self.renderers is not None:
+            renderer_func = self.renderers.get()
+            assert renderer_func is not None
+            return renderer_func(self.spec)
+        else:
+            return {}
+
+
+def default_renderer_base(
+    spec: dict[str, Any], mime_type: str, str_repr: str, **options
+) -> DefaultRendererReturnType:
+    """
+    A default renderer for Vega or VegaLite that works for modern frontends.
+
+    This renderer works with modern frontends (JupyterLab, nteract) that know
+    how to render the custom VegaLite MIME type listed above.
+    """
+    # Local import to avoid circular ImportError
+    from altair.vegalite.v5.display import VEGA_MIME_TYPE, VEGALITE_MIME_TYPE
+
+    assert isinstance(spec, dict)
+    bundle: dict[str, str | dict] = {}
+    metadata: dict[str, dict[str, Any]] = {}
+
+    if using_vegafusion():
+        spec = compile_with_vegafusion(spec)
+
+        # Swap mimetype from Vega-Lite to Vega.
+        # If mimetype was JSON, leave it alone
+        if mime_type == VEGALITE_MIME_TYPE:
+            mime_type = VEGA_MIME_TYPE
+
+    bundle[mime_type] = spec
+    bundle["text/plain"] = str_repr
+    if options:
+        metadata[mime_type] = options
+    return bundle, metadata
+
+
+def json_renderer_base(
+    spec: dict[str, Any], str_repr: str, **options
+) -> DefaultRendererReturnType:
+    """
+    A renderer that returns a MIME type of application/json.
+
+    In JupyterLab/nteract this is rendered as a nice JSON tree.
+    """
+    return default_renderer_base(
+        spec, mime_type="application/json", str_repr=str_repr, **options
+    )
+
+
+class HTMLRenderer:
+    """Object to render charts as HTML, with a unique output div each time."""
+
+    def __init__(self, output_div: str = "altair-viz-{}", **kwargs) -> None:
+        self._output_div = output_div
+        self.kwargs = kwargs
+
+    @property
+    def output_div(self) -> str:
+        return self._output_div.format(uuid.uuid4().hex)
+
+    def __call__(self, spec: dict[str, Any], **metadata) -> dict[str, str]:
+        kwargs = self.kwargs.copy()
+        kwargs.update(**metadata, output_div=self.output_div)
+        return spec_to_mimebundle(spec, format="html", **kwargs)

videollama2/lib/python3.10/site-packages/altair/utils/html.py

@@ -0,0 +1,314 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Literal
+
+import jinja2
+
+from altair.utils._importers import import_vl_convert, vl_version_for_vl_convert
+
+TemplateName = Literal["standard", "universal", "inline"]
+RenderMode = Literal["vega", "vega-lite"]
+
+HTML_TEMPLATE = jinja2.Template(
+    """
+{%- if fullhtml -%}
+<!DOCTYPE html>
+<html>
+<head>
+{%- endif %}
+  <style>
+    #{{ output_div }}.vega-embed {
+      width: 100%;
+      display: flex;
+    }
+
+    #{{ output_div }}.vega-embed details,
+    #{{ output_div }}.vega-embed details summary {
+      position: relative;
+    }
+  </style>
+{%- if not requirejs %}
+  <script type="text/javascript" src="{{ base_url }}/vega@{{ vega_version }}"></script>
+  {%- if mode == 'vega-lite' %}
+  <script type="text/javascript" src="{{ base_url }}/vega-lite@{{ vegalite_version }}"></script>
+  {%- endif %}
+  <script type="text/javascript" src="{{ base_url }}/vega-embed@{{ vegaembed_version }}"></script>
+{%- endif %}
+{%- if fullhtml %}
+{%- if requirejs %}
+<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.6/require.min.js"></script>
+<script>
+requirejs.config({
+    "paths": {
+        "vega": "{{ base_url }}/vega@{{ vega_version }}?noext",
+        "vega-lib": "{{ base_url }}/vega-lib?noext",
+        "vega-lite": "{{ base_url }}/vega-lite@{{ vegalite_version }}?noext",
+        "vega-embed": "{{ base_url }}/vega-embed@{{ vegaembed_version }}?noext",
+    }
+});
+</script>
+{%- endif %}
+</head>
+<body>
+{%- endif %}
+  <div id="{{ output_div }}"></div>
+  <script>
+    {%- if requirejs and not fullhtml %}
+    requirejs.config({
+        "paths": {
+            "vega": "{{ base_url }}/vega@{{ vega_version }}?noext",
+            "vega-lib": "{{ base_url }}/vega-lib?noext",
+            "vega-lite": "{{ base_url }}/vega-lite@{{ vegalite_version }}?noext",
+            "vega-embed": "{{ base_url }}/vega-embed@{{ vegaembed_version }}?noext",
+        }
+    });
+    {% endif %}
+    {% if requirejs -%}
+    require(['vega-embed'],
+    {%- else -%}
+    (
+    {%- endif -%}
+    function(vegaEmbed) {
+      var spec = {{ spec }};
+      var embedOpt = {{ embed_options }};
+
+      function showError(el, error){
+          el.innerHTML = ('<div style="color:red;">'
+                          + '<p>JavaScript Error: ' + error.message + '</p>'
+                          + "<p>This usually means there's a typo in your chart specification. "
+                          + "See the javascript console for the full traceback.</p>"
+                          + '</div>');
+          throw error;
+      }
+      const el = document.getElementById('{{ output_div }}');
+      vegaEmbed("#{{ output_div }}", spec, embedOpt)
+        .catch(error => showError(el, error));
+    }){% if not requirejs %}(vegaEmbed){% endif %};
+
+  </script>
+{%- if fullhtml %}
+</body>
+</html>
+{%- endif %}
+"""
+)
+
+
+HTML_TEMPLATE_UNIVERSAL = jinja2.Template(
+    """
+<style>
+  #{{ output_div }}.vega-embed {
+    width: 100%;
+    display: flex;
+  }
+
+  #{{ output_div }}.vega-embed details,
+  #{{ output_div }}.vega-embed details summary {
+    position: relative;
+  }
+</style>
+<div id="{{ output_div }}"></div>
+<script type="text/javascript">
+  var VEGA_DEBUG = (typeof VEGA_DEBUG == "undefined") ? {} : VEGA_DEBUG;
+  (function(spec, embedOpt){
+    let outputDiv = document.currentScript.previousElementSibling;
+    if (outputDiv.id !== "{{ output_div }}") {
+      outputDiv = document.getElementById("{{ output_div }}");
+    }
+    const paths = {
+      "vega": "{{ base_url }}/vega@{{ vega_version }}?noext",
+      "vega-lib": "{{ base_url }}/vega-lib?noext",
+      "vega-lite": "{{ base_url }}/vega-lite@{{ vegalite_version }}?noext",
+      "vega-embed": "{{ base_url }}/vega-embed@{{ vegaembed_version }}?noext",
+    };
+
+    function maybeLoadScript(lib, version) {
+      var key = `${lib.replace("-", "")}_version`;
+      return (VEGA_DEBUG[key] == version) ?
+        Promise.resolve(paths[lib]) :
+        new Promise(function(resolve, reject) {
+          var s = document.createElement('script');
+          document.getElementsByTagName("head")[0].appendChild(s);
+          s.async = true;
+          s.onload = () => {
+            VEGA_DEBUG[key] = version;
+            return resolve(paths[lib]);
+          };
+          s.onerror = () => reject(`Error loading script: ${paths[lib]}`);
+          s.src = paths[lib];
+        });
+    }
+
+    function showError(err) {
+      outputDiv.innerHTML = `<div class="error" style="color:red;">${err}</div>`;
+      throw err;
+    }
+
+    function displayChart(vegaEmbed) {
+      vegaEmbed(outputDiv, spec, embedOpt)
+        .catch(err => showError(`Javascript Error: ${err.message}<br>This usually means there's a typo in your chart specification. See the javascript console for the full traceback.`));
+    }
+
+    if(typeof define === "function" && define.amd) {
+      requirejs.config({paths});
+      require(["vega-embed"], displayChart, err => showError(`Error loading script: ${err.message}`));
+    } else {
+      maybeLoadScript("vega", "{{vega_version}}")
+        .then(() => maybeLoadScript("vega-lite", "{{vegalite_version}}"))
+        .then(() => maybeLoadScript("vega-embed", "{{vegaembed_version}}"))
+        .catch(showError)
+        .then(() => displayChart(vegaEmbed));
+    }
+  })({{ spec }}, {{ embed_options }});
+</script>
+"""
+)
+
+
+# This is like the HTML_TEMPLATE template, but includes vega javascript inline
+# so that the resulting file is not dependent on external resources. This was
+# ported over from altair_saver.
+#
+# implies requirejs=False and full_html=True
+INLINE_HTML_TEMPLATE = jinja2.Template(
+    """\
+<!DOCTYPE html>
+<html>
+<head>
+  <style>
+    #{{ output_div }}.vega-embed {
+      width: 100%;
+      display: flex;
+    }
+
+    #{{ output_div }}.vega-embed details,
+    #{{ output_div }}.vega-embed details summary {
+      position: relative;
+    }
+  </style>
+  <script type="text/javascript">
+    // vega-embed.js bundle with Vega-Lite version v{{ vegalite_version }}
+    {{ vegaembed_script }}
+  </script>
+</head>
+<body>
+<div class="vega-visualization" id="{{ output_div }}"></div>
+<script type="text/javascript">
+  const spec = {{ spec }};
+  const embedOpt = {{ embed_options }};
+  vegaEmbed('#{{ output_div }}', spec, embedOpt).catch(console.error);
+</script>
+</body>
+</html>
+"""
+)
+
+
+TEMPLATES: dict[TemplateName, jinja2.Template] = {
+    "standard": HTML_TEMPLATE,
+    "universal": HTML_TEMPLATE_UNIVERSAL,
+    "inline": INLINE_HTML_TEMPLATE,
+}
+
+
+def spec_to_html(
+    spec: dict[str, Any],
+    mode: RenderMode,
+    vega_version: str | None,
+    vegaembed_version: str | None,
+    vegalite_version: str | None = None,
+    base_url: str = "https://cdn.jsdelivr.net/npm",
+    output_div: str = "vis",
+    embed_options: dict[str, Any] | None = None,
+    json_kwds: dict[str, Any] | None = None,
+    fullhtml: bool = True,
+    requirejs: bool = False,
+    template: jinja2.Template | TemplateName = "standard",
+) -> str:
+    """
+    Embed a Vega/Vega-Lite spec into an HTML page.
+
+    Parameters
+    ----------
+    spec : dict
+        a dictionary representing a vega-lite plot spec.
+    mode : string {'vega' | 'vega-lite'}
+        The rendering mode. This value is overridden by embed_options['mode'],
+        if it is present.
+    vega_version : string
+        For html output, the version of vega.js to use.
+    vegalite_version : string
+        For html output, the version of vegalite.js to use.
+    vegaembed_version : string
+        For html output, the version of vegaembed.js to use.
+    base_url : string (optional)
+        The base url from which to load the javascript libraries.
+    output_div : string (optional)
+        The id of the div element where the plot will be shown.
+    embed_options : dict (optional)
+        Dictionary of options to pass to the vega-embed script. Default
+        entry is {'mode': mode}.
+    json_kwds : dict (optional)
+        Dictionary of keywords to pass to json.dumps().
+    fullhtml : boolean (optional)
+        If True (default) then return a full html page. If False, then return
+        an HTML snippet that can be embedded into an HTML page.
+    requirejs : boolean (optional)
+        If False (default) then load libraries from base_url using <script>
+        tags. If True, then load libraries using requirejs
+    template : jinja2.Template or string (optional)
+        Specify the template to use (default = 'standard'). If template is a
+        string, it must be one of {'universal', 'standard', 'inline'}. Otherwise, it
+        can be a jinja2.Template object containing a custom template.
+
+    Returns
+    -------
+    output : string
+        an HTML string for rendering the chart.
+    """
+    embed_options = embed_options or {}
+    json_kwds = json_kwds or {}
+
+    mode = embed_options.setdefault("mode", mode)
+
+    if mode not in {"vega", "vega-lite"}:
+        msg = "mode must be either 'vega' or 'vega-lite'"
+        raise ValueError(msg)
+
+    if vega_version is None:
+        msg = "must specify vega_version"
+        raise ValueError(msg)
+
+    if vegaembed_version is None:
+        msg = "must specify vegaembed_version"
+        raise ValueError(msg)
+
+    if mode == "vega-lite" and vegalite_version is None:
+        msg = "must specify vega-lite version for mode='vega-lite'"
+        raise ValueError(msg)
+
+    render_kwargs = {}
+    if template == "inline":
+        vlc = import_vl_convert()
+        vl_version = vl_version_for_vl_convert()
+        render_kwargs["vegaembed_script"] = vlc.javascript_bundle(vl_version=vl_version)
+
+    jinja_template = TEMPLATES.get(template, template)  # type: ignore[arg-type]
+    if not hasattr(jinja_template, "render"):
+        msg = f"Invalid template: {jinja_template}"
+        raise ValueError(msg)
+
+    return jinja_template.render(
+        spec=json.dumps(spec, **json_kwds),
+        embed_options=json.dumps(embed_options),
+        mode=mode,
+        vega_version=vega_version,
+        vegalite_version=vegalite_version,
+        vegaembed_version=vegaembed_version,
+        base_url=base_url,
+        output_div=output_div,
+        fullhtml=fullhtml,
+        requirejs=requirejs,
+        **render_kwargs,
+    )

videollama2/lib/python3.10/site-packages/altair/utils/plugin_registry.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+from functools import partial
+from importlib.metadata import entry_points
+from typing import TYPE_CHECKING, Any, Callable, Generic, cast
+from typing_extensions import TypeAliasType, TypeIs, TypeVar
+
+from altair.utils.deprecation import deprecated_warn
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+T = TypeVar("T")
+R = TypeVar("R")
+Plugin = TypeAliasType("Plugin", Callable[..., R], type_params=(R,))
+PluginT = TypeVar("PluginT", bound=Plugin[Any])
+IsPlugin = Callable[[object], TypeIs[Plugin[Any]]]
+
+
+def _is_type(tp: type[T], /) -> Callable[[object], TypeIs[type[T]]]:
+    """
+    Converts a type to guard function.
+
+    Added for compatibility with original `PluginRegistry` default.
+    """
+
+    def func(obj: object, /) -> TypeIs[type[T]]:
+        return isinstance(obj, tp)
+
+    return func
+
+
+class NoSuchEntryPoint(Exception):
+    def __init__(self, group, name):
+        self.group = group
+        self.name = name
+
+    def __str__(self):
+        return f"No {self.name!r} entry point found in group {self.group!r}"
+
+
+class PluginEnabler:
+    """
+    Context manager for enabling plugins.
+
+    This object lets you use enable() as a context manager to
+    temporarily enable a given plugin::
+
+        with plugins.enable("name"):
+            do_something()  # 'name' plugin temporarily enabled
+        # plugins back to original state
+    """
+
+    def __init__(self, registry: PluginRegistry, name: str, **options):
+        self.registry: PluginRegistry = registry
+        self.name: str = name
+        self.options: dict[str, Any] = options
+        self.original_state: dict[str, Any] = registry._get_state()
+        self.registry._enable(name, **options)
+
+    def __enter__(self) -> PluginEnabler:
+        return self
+
+    def __exit__(self, typ: type, value: Exception, traceback: TracebackType) -> None:
+        self.registry._set_state(self.original_state)
+
+    def __repr__(self) -> str:
+        return f"{self.registry.__class__.__name__}.enable({self.name!r})"
+
+
+class PluginRegistry(Generic[PluginT, R]):
+    """
+    A registry for plugins.
+
+    This is a plugin registry that allows plugins to be loaded/registered
+    in two ways:
+
+    1. Through an explicit call to ``.register(name, value)``.
+    2. By looking for other Python packages that are installed and provide
+       a setuptools entry point group.
+
+    When you create an instance of this class, provide the name of the
+    entry point group to use::
+
+        reg = PluginRegister("my_entrypoint_group")
+
+    """
+
+    # this is a mapping of name to error message to allow custom error messages
+    # in case an entrypoint is not found
+    entrypoint_err_messages: dict[str, str] = {}
+
+    # global settings is a key-value mapping of settings that are stored globally
+    # in the registry rather than passed to the plugins
+    _global_settings: dict[str, Any] = {}
+
+    def __init__(
+        self, entry_point_group: str = "", plugin_type: IsPlugin = callable
+    ) -> None:
+        """
+        Create a PluginRegistry for a named entry point group.
+
+        Parameters
+        ----------
+        entry_point_group: str
+            The name of the entry point group.
+        plugin_type
+            A type narrowing function that will optionally be used for runtime
+            type checking loaded plugins.
+
+        References
+        ----------
+        https://typing.readthedocs.io/en/latest/spec/narrowing.html
+        """
+        self.entry_point_group: str = entry_point_group
+        self.plugin_type: IsPlugin
+        if plugin_type is not callable and isinstance(plugin_type, type):
+            msg = (
+                f"Pass a callable `TypeIs` function to `plugin_type` instead.\n"
+                f"{type(self).__name__!r}(plugin_type)\n\n"
+                f"See also:\n"
+                f"https://typing.readthedocs.io/en/latest/spec/narrowing.html\n"
+                f"https://docs.astral.sh/ruff/rules/assert/"
+            )
+            deprecated_warn(msg, version="5.4.0")
+            self.plugin_type = cast(IsPlugin, _is_type(plugin_type))
+        else:
+            self.plugin_type = plugin_type
+        self._active: Plugin[R] | None = None
+        self._active_name: str = ""
+        self._plugins: dict[str, PluginT] = {}
+        self._options: dict[str, Any] = {}
+        self._global_settings: dict[str, Any] = self.__class__._global_settings.copy()
+
+    def register(self, name: str, value: PluginT | None) -> PluginT | None:
+        """
+        Register a plugin by name and value.
+
+        This method is used for explicit registration of a plugin and shouldn't be
+        used to manage entry point managed plugins, which are auto-loaded.
+
+        Parameters
+        ----------
+        name: str
+            The name of the plugin.
+        value: PluginType or None
+            The actual plugin object to register or None to unregister that plugin.
+
+        Returns
+        -------
+        plugin: PluginType or None
+            The plugin that was registered or unregistered.
+        """
+        if value is None:
+            return self._plugins.pop(name, None)
+        elif self.plugin_type(value):
+            self._plugins[name] = value
+            return value
+        else:
+            msg = f"{type(value).__name__!r} is not compatible with {type(self).__name__!r}"
+            raise TypeError(msg)
+
+    def names(self) -> list[str]:
+        """List the names of the registered and entry points plugins."""
+        exts = list(self._plugins.keys())
+        e_points = importlib_metadata_get(self.entry_point_group)
+        more_exts = [ep.name for ep in e_points]
+        exts.extend(more_exts)
+        return sorted(set(exts))
+
+    def _get_state(self) -> dict[str, Any]:
+        """Return a dictionary representing the current state of the registry."""
+        return {
+            "_active": self._active,
+            "_active_name": self._active_name,
+            "_plugins": self._plugins.copy(),
+            "_options": self._options.copy(),
+            "_global_settings": self._global_settings.copy(),
+        }
+
+    def _set_state(self, state: dict[str, Any]) -> None:
+        """Reset the state of the registry."""
+        assert set(state.keys()) == {
+            "_active",
+            "_active_name",
+            "_plugins",
+            "_options",
+            "_global_settings",
+        }
+        for key, val in state.items():
+            setattr(self, key, val)
+
+    def _enable(self, name: str, **options) -> None:
+        if name not in self._plugins:
+            try:
+                (ep,) = (
+                    ep
+                    for ep in importlib_metadata_get(self.entry_point_group)
+                    if ep.name == name
+                )
+            except ValueError as err:
+                if name in self.entrypoint_err_messages:
+                    raise ValueError(self.entrypoint_err_messages[name]) from err
+                else:
+                    raise NoSuchEntryPoint(self.entry_point_group, name) from err
+            value = cast(PluginT, ep.load())
+            self.register(name, value)
+        self._active_name = name
+        self._active = self._plugins[name]
+        for key in set(options.keys()) & set(self._global_settings.keys()):
+            self._global_settings[key] = options.pop(key)
+        self._options = options
+
+    def enable(self, name: str | None = None, **options) -> PluginEnabler:
+        """
+        Enable a plugin by name.
+
+        This can be either called directly, or used as a context manager.
+
+        Parameters
+        ----------
+        name : string (optional)
+            The name of the plugin to enable. If not specified, then use the
+            current active name.
+        **options :
+            Any additional parameters will be passed to the plugin as keyword
+            arguments
+
+        Returns
+        -------
+        PluginEnabler:
+            An object that allows enable() to be used as a context manager
+        """
+        if name is None:
+            name = self.active
+        return PluginEnabler(self, name, **options)
+
+    @property
+    def active(self) -> str:
+        """Return the name of the currently active plugin."""
+        return self._active_name
+
+    @property
+    def options(self) -> dict[str, Any]:
+        """Return the current options dictionary."""
+        return self._options
+
+    def get(self) -> partial[R] | Plugin[R] | None:
+        """Return the currently active plugin."""
+        if (func := self._active) and self.plugin_type(func):
+            return partial(func, **self._options) if self._options else func
+        elif self._active is not None:
+            msg = (
+                f"{type(self).__name__!r} requires all plugins to be callable objects, "
+                f"but {type(self._active).__name__!r} is not callable."
+            )
+            raise TypeError(msg)
+        elif TYPE_CHECKING:
+            # NOTE: The `None` return is implicit, but `mypy` isn't satisfied
+            # - `ruff` will factor out explicit `None` return
+            # - `pyright` has no issue
+            raise NotImplementedError
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(active={self.active!r}, registered={self.names()!r})"
+
+
+def importlib_metadata_get(group):
+    ep = entry_points()
+    # 'select' was introduced in Python 3.10 and 'get' got deprecated
+    # We don't check for Python version here as by checking with hasattr we
+    # also get compatibility with the importlib_metadata package which had a different
+    # deprecation cycle for 'get'
+    if hasattr(ep, "select"):
+        return ep.select(group=group)  # pyright: ignore
+    else:
+        return ep.get(group, [])

videollama2/lib/python3.10/site-packages/altair/utils/save.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import json
+import pathlib
+import warnings
+from typing import IO, TYPE_CHECKING, Any, Literal
+
+from altair.utils._vegafusion_data import using_vegafusion
+from altair.utils.deprecation import deprecated_warn
+from altair.vegalite.v5.data import data_transformers
+
+from .mimebundle import spec_to_mimebundle
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def write_file_or_filename(
+    fp: str | Path | IO,
+    content: str | bytes,
+    mode: str = "w",
+    encoding: str | None = None,
+) -> None:
+    """Write content to fp, whether fp is a string, a pathlib Path or a file-like object."""
+    if isinstance(fp, (str, pathlib.Path)):
+        with pathlib.Path(fp).open(mode=mode, encoding=encoding) as f:
+            f.write(content)
+    else:
+        fp.write(content)
+
+
+def set_inspect_format_argument(
+    format: str | None, fp: str | Path | IO, inline: bool
+) -> str:
+    """Inspect the format argument in the save function."""
+    if format is None:
+        if isinstance(fp, (str, pathlib.Path)):
+            format = pathlib.Path(fp).suffix.lstrip(".")
+        else:
+            msg = (
+                "must specify file format: "
+                "['png', 'svg', 'pdf', 'html', 'json', 'vega']"
+            )
+            raise ValueError(msg)
+
+    if format != "html" and inline:
+        warnings.warn("inline argument ignored for non HTML formats.", stacklevel=1)
+
+    return format
+
+
+def set_inspect_mode_argument(
+    mode: Literal["vega-lite"] | None,
+    embed_options: dict[str, Any],
+    spec: dict[str, Any],
+    vegalite_version: str | None,
+) -> Literal["vega-lite"]:
+    """Inspect the mode argument in the save function."""
+    if mode is None:
+        if "mode" in embed_options:
+            mode = embed_options["mode"]
+        elif "$schema" in spec:
+            mode = spec["$schema"].split("/")[-2]
+        else:
+            mode = "vega-lite"
+
+    if mode != "vega-lite":
+        msg = "mode must be 'vega-lite', " f"not '{mode}'"
+        raise ValueError(msg)
+
+    if mode == "vega-lite" and vegalite_version is None:
+        msg = "must specify vega-lite version"
+        raise ValueError(msg)
+
+    return mode
+
+
+def save(
+    chart,
+    fp: str | Path | IO,
+    vega_version: str | None,
+    vegaembed_version: str | None,
+    format: Literal["json", "html", "png", "svg", "pdf"] | None = None,
+    mode: Literal["vega-lite"] | None = None,
+    vegalite_version: str | None = None,
+    embed_options: dict | None = None,
+    json_kwds: dict | None = None,
+    scale_factor: float = 1,
+    engine: Literal["vl-convert"] | None = None,
+    inline: bool = False,
+    **kwargs,
+) -> None:
+    """
+    Save a chart to file in a variety of formats.
+
+    Supported formats are [json, html, png, svg, pdf]
+
+    Parameters
+    ----------
+    chart : alt.Chart
+        the chart instance to save
+    fp : string filename, pathlib.Path or file-like object
+        file to which to write the chart.
+    format : string (optional)
+        the format to write: one of ['json', 'html', 'png', 'svg', 'pdf'].
+        If not specified, the format will be determined from the filename.
+    mode : string (optional)
+        Must be 'vega-lite'. If not specified, then infer the mode from
+        the '$schema' property of the spec, or the ``opt`` dictionary.
+        If it's not specified in either of those places, then use 'vega-lite'.
+    vega_version : string (optional)
+        For html output, the version of vega.js to use
+    vegalite_version : string (optional)
+        For html output, the version of vegalite.js to use
+    vegaembed_version : string (optional)
+        For html output, the version of vegaembed.js to use
+    embed_options : dict (optional)
+        The vegaEmbed options dictionary. Default is {}
+        (See https://github.com/vega/vega-embed for details)
+    json_kwds : dict (optional)
+        Additional keyword arguments are passed to the output method
+        associated with the specified format.
+    scale_factor : float (optional)
+        scale_factor to use to change size/resolution of png or svg output
+    engine: string {'vl-convert'}
+        the conversion engine to use for 'png', 'svg', and 'pdf' formats
+    inline: bool (optional)
+        If False (default), the required JavaScript libraries are loaded
+        from a CDN location in the resulting html file.
+        If True, the required JavaScript libraries are inlined into the resulting
+        html file so that it will work without an internet connection.
+        The vl-convert-python package is required if True.
+    **kwargs :
+        additional kwargs passed to spec_to_mimebundle.
+    """
+    if _ := kwargs.pop("webdriver", None):
+        deprecated_warn(
+            "The webdriver argument is not relevant for the new vl-convert engine which replaced altair_saver. "
+            "The argument will be removed in a future release.",
+            version="5.0.0",
+        )
+
+    json_kwds = json_kwds or {}
+    encoding = kwargs.get("encoding", "utf-8")
+    format = set_inspect_format_argument(format, fp, inline)  # type: ignore[assignment]
+
+    def perform_save() -> None:
+        spec = chart.to_dict(context={"pre_transform": False})
+
+        inner_mode = set_inspect_mode_argument(
+            mode, embed_options or {}, spec, vegalite_version
+        )
+
+        if format == "json":
+            json_spec = json.dumps(spec, **json_kwds)
+            write_file_or_filename(fp, json_spec, mode="w", encoding=encoding)
+        elif format == "html":
+            if inline:
+                kwargs["template"] = "inline"
+            mb_html = spec_to_mimebundle(
+                spec=spec,
+                format=format,
+                mode=inner_mode,
+                vega_version=vega_version,
+                vegalite_version=vegalite_version,
+                vegaembed_version=vegaembed_version,
+                embed_options=embed_options,
+                json_kwds=json_kwds,
+                **kwargs,
+            )
+            write_file_or_filename(
+                fp, mb_html["text/html"], mode="w", encoding=encoding
+            )
+        elif format == "png":
+            mb_png = spec_to_mimebundle(
+                spec=spec,
+                format=format,
+                mode=inner_mode,
+                vega_version=vega_version,
+                vegalite_version=vegalite_version,
+                vegaembed_version=vegaembed_version,
+                embed_options=embed_options,
+                scale_factor=scale_factor,
+                engine=engine,
+                **kwargs,
+            )
+            write_file_or_filename(fp, mb_png[0]["image/png"], mode="wb")
+        elif format in {"svg", "pdf", "vega"}:
+            mb_any = spec_to_mimebundle(
+                spec=spec,
+                format=format,
+                mode=inner_mode,
+                vega_version=vega_version,
+                vegalite_version=vegalite_version,
+                vegaembed_version=vegaembed_version,
+                embed_options=embed_options,
+                scale_factor=scale_factor,
+                engine=engine,
+                **kwargs,
+            )
+            if format == "pdf":
+                write_file_or_filename(fp, mb_any["application/pdf"], mode="wb")
+            else:
+                write_file_or_filename(
+                    fp, mb_any["image/svg+xml"], mode="w", encoding=encoding
+                )
+        else:
+            msg = f"Unsupported format: '{format}'"
+            raise ValueError(msg)
+
+    if using_vegafusion():
+        # When the vegafusion data transformer is enabled, transforms will be
+        # evaluated during save and the resulting data will be included in the
+        # vega specification that is saved.
+        with data_transformers.disable_max_rows():
+            perform_save()
+    else:
+        # Temporarily turn off any data transformers so that all data is inlined
+        # when calling chart.to_dict. This is relevant for vl-convert which cannot access
+        # local json files which could be created by a json data transformer. Furthermore,
+        # we don't exit the with statement until this function completed due to the issue
+        # described at https://github.com/vega/vl-convert/issues/31
+        with data_transformers.enable("default"), data_transformers.disable_max_rows():
+            perform_save()

videollama2/lib/python3.10/site-packages/altair/utils/schemapi.py

@@ -0,0 +1,1471 @@
+# The contents of this file are automatically written by
+# tools/generate_schema_wrapper.py. Do not modify directly.
+from __future__ import annotations
+
+import contextlib
+import copy
+import inspect
+import json
+import sys
+import textwrap
+from collections import defaultdict
+from functools import partial
+from importlib.metadata import version as importlib_version
+from itertools import chain, zip_longest
+from math import ceil
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Final,
+    Iterable,
+    Iterator,
+    List,
+    Literal,
+    Sequence,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+from typing_extensions import TypeAlias
+
+import jsonschema
+import jsonschema.exceptions
+import jsonschema.validators
+import narwhals.stable.v1 as nw
+from packaging.version import Version
+
+# This leads to circular imports with the vegalite module. Currently, this works
+# but be aware that when you access it in this script, the vegalite module might
+# not yet be fully instantiated in case your code is being executed during import time
+from altair import vegalite
+
+if TYPE_CHECKING:
+    from typing import ClassVar
+
+    from referencing import Registry
+
+    from altair.typing import ChartType
+
+    if sys.version_info >= (3, 13):
+        from typing import TypeIs
+    else:
+        from typing_extensions import TypeIs
+
+    if sys.version_info >= (3, 11):
+        from typing import Never, Self
+    else:
+        from typing_extensions import Never, Self
+
+ValidationErrorList: TypeAlias = List[jsonschema.exceptions.ValidationError]
+GroupedValidationErrors: TypeAlias = Dict[str, ValidationErrorList]
+
+# This URI is arbitrary and could be anything else. It just cannot be an empty
+# string as we need to reference the schema registered in
+# the referencing.Registry.
+_VEGA_LITE_ROOT_URI: Final = "urn:vega-lite-schema"
+
+# Ideally, jsonschema specification would be parsed from the current Vega-Lite
+# schema instead of being hardcoded here as a default value.
+# However, due to circular imports between this module and the altair.vegalite
+# modules, this information is not yet available at this point as altair.vegalite
+# is only partially loaded. The draft version which is used is unlikely to
+# change often so it's ok to keep this. There is also a test which validates
+# that this value is always the same as in the Vega-Lite schema.
+_DEFAULT_JSON_SCHEMA_DRAFT_URL: Final = "http://json-schema.org/draft-07/schema#"
+
+
+# If DEBUG_MODE is True, then schema objects are converted to dict and
+# validated at creation time. This slows things down, particularly for
+# larger specs, but leads to much more useful tracebacks for the user.
+# Individual schema classes can override this by setting the
+# class-level _class_is_valid_at_instantiation attribute to False
+DEBUG_MODE: bool = True
+
+jsonschema_version_str = importlib_version("jsonschema")
+
+
+def enable_debug_mode() -> None:
+    global DEBUG_MODE
+    DEBUG_MODE = True
+
+
+def disable_debug_mode() -> None:
+    global DEBUG_MODE
+    DEBUG_MODE = False
+
+
+@contextlib.contextmanager
+def debug_mode(arg: bool) -> Iterator[None]:
+    global DEBUG_MODE
+    original = DEBUG_MODE
+    DEBUG_MODE = arg
+    try:
+        yield
+    finally:
+        DEBUG_MODE = original
+
+
+@overload
+def validate_jsonschema(
+    spec: Any,
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None = ...,
+    *,
+    raise_error: Literal[True] = ...,
+) -> Never: ...
+
+
+@overload
+def validate_jsonschema(
+    spec: Any,
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None = ...,
+    *,
+    raise_error: Literal[False],
+) -> jsonschema.exceptions.ValidationError | None: ...
+
+
+def validate_jsonschema(
+    spec,
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None = None,
+    *,
+    raise_error: bool = True,
+) -> jsonschema.exceptions.ValidationError | None:
+    """
+    Validates the passed in spec against the schema in the context of the rootschema.
+
+    If any errors are found, they are deduplicated and prioritized
+    and only the most relevant errors are kept. Errors are then either raised
+    or returned, depending on the value of `raise_error`.
+    """
+    errors = _get_errors_from_spec(spec, schema, rootschema=rootschema)
+    if errors:
+        leaf_errors = _get_leaves_of_error_tree(errors)
+        grouped_errors = _group_errors_by_json_path(leaf_errors)
+        grouped_errors = _subset_to_most_specific_json_paths(grouped_errors)
+        grouped_errors = _deduplicate_errors(grouped_errors)
+
+        # Nothing special about this first error but we need to choose one
+        # which can be raised
+        main_error: Any = next(iter(grouped_errors.values()))[0]
+        # All errors are then attached as a new attribute to ValidationError so that
+        # they can be used in SchemaValidationError to craft a more helpful
+        # error message. Setting a new attribute like this is not ideal as
+        # it then no longer matches the type ValidationError. It would be better
+        # to refactor this function to never raise but only return errors.
+        main_error._all_errors = grouped_errors
+        if raise_error:
+            raise main_error
+        else:
+            return main_error
+    else:
+        return None
+
+
+def _get_errors_from_spec(
+    spec: dict[str, Any],
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None = None,
+) -> ValidationErrorList:
+    """
+    Uses the relevant jsonschema validator to validate the passed in spec against the schema using the rootschema to resolve references.
+
+    The schema and rootschema themselves are not validated but instead considered as valid.
+    """
+    # We don't use jsonschema.validate as this would validate the schema itself.
+    # Instead, we pass the schema directly to the validator class. This is done for
+    # two reasons: The schema comes from Vega-Lite and is not based on the user
+    # input, therefore there is no need to validate it in the first place. Furthermore,
+    # the "uri-reference" format checker fails for some of the references as URIs in
+    # "$ref" are not encoded,
+    # e.g. '#/definitions/ValueDefWithCondition<MarkPropFieldOrDatumDef,
+    # (Gradient|string|null)>' would be a valid $ref in a Vega-Lite schema but
+    # it is not a valid URI reference due to the characters such as '<'.
+
+    json_schema_draft_url = _get_json_schema_draft_url(rootschema or schema)
+    validator_cls = jsonschema.validators.validator_for(
+        {"$schema": json_schema_draft_url}
+    )
+    validator_kwargs: dict[str, Any] = {}
+    if hasattr(validator_cls, "FORMAT_CHECKER"):
+        validator_kwargs["format_checker"] = validator_cls.FORMAT_CHECKER
+
+    if _use_referencing_library():
+        schema = _prepare_references_in_schema(schema)
+        validator_kwargs["registry"] = _get_referencing_registry(
+            rootschema or schema, json_schema_draft_url
+        )
+
+    else:
+        # No resolver is necessary if the schema is already the full schema
+        validator_kwargs["resolver"] = (
+            jsonschema.RefResolver.from_schema(rootschema)
+            if rootschema is not None
+            else None
+        )
+
+    validator = validator_cls(schema, **validator_kwargs)
+    errors = list(validator.iter_errors(spec))
+    return errors
+
+
+def _get_json_schema_draft_url(schema: dict[str, Any]) -> str:
+    return schema.get("$schema", _DEFAULT_JSON_SCHEMA_DRAFT_URL)
+
+
+def _use_referencing_library() -> bool:
+    """In version 4.18.0, the jsonschema package deprecated RefResolver in favor of the referencing library."""
+    return Version(jsonschema_version_str) >= Version("4.18")
+
+
+def _prepare_references_in_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    # Create a copy so that $ref is not modified in the original schema in case
+    # that it would still reference a dictionary which might be attached to
+    # an Altair class _schema attribute
+    schema = copy.deepcopy(schema)
+
+    def _prepare_refs(d: dict[str, Any]) -> dict[str, Any]:
+        """
+        Add _VEGA_LITE_ROOT_URI in front of all $ref values.
+
+        This function recursively iterates through the whole dictionary.
+
+        $ref values can only be nested in dictionaries or lists
+        as the passed in `d` dictionary comes from the Vega-Lite json schema
+        and in json we only have arrays (-> lists in Python) and objects
+        (-> dictionaries in Python) which we need to iterate through.
+        """
+        for key, value in d.items():
+            if key == "$ref":
+                d[key] = _VEGA_LITE_ROOT_URI + d[key]
+            elif isinstance(value, dict):
+                d[key] = _prepare_refs(value)
+            elif isinstance(value, list):
+                prepared_values = []
+                for v in value:
+                    if isinstance(v, dict):
+                        v = _prepare_refs(v)
+                    prepared_values.append(v)
+                d[key] = prepared_values
+        return d
+
+    schema = _prepare_refs(schema)
+    return schema
+
+
+# We do not annotate the return value here as the referencing library is not always
+# available and this function is only executed in those cases.
+def _get_referencing_registry(
+    rootschema: dict[str, Any], json_schema_draft_url: str | None = None
+) -> Registry:
+    # Referencing is a dependency of newer jsonschema versions, starting with the
+    # version that is specified in _use_referencing_library and we therefore
+    # can expect that it is installed if the function returns True.
+    # We ignore 'import' mypy errors which happen when the referencing library
+    # is not installed. That's ok as in these cases this function is not called.
+    # We also have to ignore 'unused-ignore' errors as mypy raises those in case
+    # referencing is installed.
+    import referencing  # type: ignore[import,unused-ignore]
+    import referencing.jsonschema  # type: ignore[import,unused-ignore]
+
+    if json_schema_draft_url is None:
+        json_schema_draft_url = _get_json_schema_draft_url(rootschema)
+
+    specification = referencing.jsonschema.specification_with(json_schema_draft_url)
+    resource = specification.create_resource(rootschema)
+    return referencing.Registry().with_resource(
+        uri=_VEGA_LITE_ROOT_URI, resource=resource
+    )
+
+
+def _json_path(err: jsonschema.exceptions.ValidationError) -> str:
+    """
+    Drop in replacement for the .json_path property of the jsonschema ValidationError class.
+
+    This is not available as property for ValidationError with jsonschema<4.0.1.
+
+    More info, see https://github.com/vega/altair/issues/3038.
+    """
+    path = "$"
+    for elem in err.absolute_path:
+        if isinstance(elem, int):
+            path += "[" + str(elem) + "]"
+        else:
+            path += "." + elem
+    return path
+
+
+def _group_errors_by_json_path(
+    errors: ValidationErrorList,
+) -> GroupedValidationErrors:
+    """
+    Groups errors by the `json_path` attribute of the jsonschema ValidationError class.
+
+    This attribute contains the path to the offending element within
+    a chart specification and can therefore be considered as an identifier of an
+    'issue' in the chart that needs to be fixed.
+    """
+    errors_by_json_path = defaultdict(list)
+    for err in errors:
+        err_key = getattr(err, "json_path", _json_path(err))
+        errors_by_json_path[err_key].append(err)
+    return dict(errors_by_json_path)
+
+
+def _get_leaves_of_error_tree(
+    errors: ValidationErrorList,
+) -> ValidationErrorList:
+    """
+    For each error in `errors`, it traverses down the "error tree" that is generated by the jsonschema library to find and return all "leaf" errors.
+
+    These are errors which have no further errors that caused it and so they are the most specific errors
+    with the most specific error messages.
+    """
+    leaves: ValidationErrorList = []
+    for err in errors:
+        if err.context:
+            # This means that the error `err` was caused by errors in subschemas.
+            # The list of errors from the subschemas are available in the property
+            # `context`.
+            leaves.extend(_get_leaves_of_error_tree(err.context))
+        else:
+            leaves.append(err)
+    return leaves
+
+
+def _subset_to_most_specific_json_paths(
+    errors_by_json_path: GroupedValidationErrors,
+) -> GroupedValidationErrors:
+    """
+    Removes key (json path), value (errors) pairs where the json path is fully contained in another json path.
+
+    For example if `errors_by_json_path` has two keys, `$.encoding.X` and `$.encoding.X.tooltip`,
+    then the first one will be removed and only the second one is returned.
+
+    This is done under the assumption that more specific json paths give more helpful error messages to the user.
+    """
+    errors_by_json_path_specific: GroupedValidationErrors = {}
+    for json_path, errors in errors_by_json_path.items():
+        if not _contained_at_start_of_one_of_other_values(
+            json_path, list(errors_by_json_path.keys())
+        ):
+            errors_by_json_path_specific[json_path] = errors
+    return errors_by_json_path_specific
+
+
+def _contained_at_start_of_one_of_other_values(x: str, values: Sequence[str]) -> bool:
+    # Does not count as "contained at start of other value" if the values are
+    # the same. These cases should be handled separately
+    return any(value.startswith(x) for value in values if x != value)
+
+
+def _deduplicate_errors(
+    grouped_errors: GroupedValidationErrors,
+) -> GroupedValidationErrors:
+    """
+    Some errors have very similar error messages or are just in general not helpful for a user.
+
+    This function removes as many of these cases as possible and
+    can be extended over time to handle new cases that come up.
+    """
+    grouped_errors_deduplicated: GroupedValidationErrors = {}
+    for json_path, element_errors in grouped_errors.items():
+        errors_by_validator = _group_errors_by_validator(element_errors)
+
+        deduplication_functions = {
+            "enum": _deduplicate_enum_errors,
+            "additionalProperties": _deduplicate_additional_properties_errors,
+        }
+        deduplicated_errors: ValidationErrorList = []
+        for validator, errors in errors_by_validator.items():
+            deduplication_func = deduplication_functions.get(validator)
+            if deduplication_func is not None:
+                errors = deduplication_func(errors)
+            deduplicated_errors.extend(_deduplicate_by_message(errors))
+
+        # Removes any ValidationError "'value' is a required property" as these
+        # errors are unlikely to be the relevant ones for the user. They come from
+        # validation against a schema definition where the output of `alt.value`
+        # would be valid. However, if a user uses `alt.value`, the `value` keyword
+        # is included automatically from that function and so it's unlikely
+        # that this was what the user intended if the keyword is not present
+        # in the first place.
+        deduplicated_errors = [
+            err for err in deduplicated_errors if not _is_required_value_error(err)
+        ]
+
+        grouped_errors_deduplicated[json_path] = deduplicated_errors
+    return grouped_errors_deduplicated
+
+
+def _is_required_value_error(err: jsonschema.exceptions.ValidationError) -> bool:
+    return err.validator == "required" and err.validator_value == ["value"]
+
+
+def _group_errors_by_validator(errors: ValidationErrorList) -> GroupedValidationErrors:
+    """
+    Groups the errors by the json schema "validator" that casued the error.
+
+    For example if the error is that a value is not one of an enumeration in the json schema
+    then the "validator" is `"enum"`, if the error is due to an unknown property that
+    was set although no additional properties are allowed then "validator" is
+    `"additionalProperties`, etc.
+    """
+    errors_by_validator: defaultdict[str, ValidationErrorList] = defaultdict(list)
+    for err in errors:
+        # Ignore mypy error as err.validator as it wrongly sees err.validator
+        # as of type Optional[Validator] instead of str which it is according
+        # to the documentation and all tested cases
+        errors_by_validator[err.validator].append(err)  # type: ignore[index]
+    return dict(errors_by_validator)
+
+
+def _deduplicate_enum_errors(errors: ValidationErrorList) -> ValidationErrorList:
+    """
+    Deduplicate enum errors by removing the errors where the allowed values are a subset of another error.
+
+    For example, if `enum` contains two errors and one has `validator_value` (i.e. accepted values) ["A", "B"] and the
+    other one ["A", "B", "C"] then the first one is removed and the final
+    `enum` list only contains the error with ["A", "B", "C"].
+    """
+    if len(errors) > 1:
+        # Values (and therefore `validator_value`) of an enum are always arrays,
+        # see https://json-schema.org/understanding-json-schema/reference/generic.html#enumerated-values
+        # which is why we can use join below
+        value_strings = [",".join(err.validator_value) for err in errors]  # type: ignore
+        longest_enums: ValidationErrorList = []
+        for value_str, err in zip(value_strings, errors):
+            if not _contained_at_start_of_one_of_other_values(value_str, value_strings):
+                longest_enums.append(err)
+        errors = longest_enums
+    return errors
+
+
+def _deduplicate_additional_properties_errors(
+    errors: ValidationErrorList,
+) -> ValidationErrorList:
+    """
+    If there are multiple additional property errors it usually means that the offending element was validated against multiple schemas and its parent is a common anyOf validator.
+
+    The error messages produced from these cases are usually
+    very similar and we just take the shortest one. For example,
+    the following 3 errors are raised for the `unknown` channel option in
+    `alt.X("variety", unknown=2)`:
+    - "Additional properties are not allowed ('unknown' was unexpected)"
+    - "Additional properties are not allowed ('field', 'unknown' were unexpected)"
+    - "Additional properties are not allowed ('field', 'type', 'unknown' were unexpected)".
+    """
+    if len(errors) > 1:
+        # Test if all parent errors are the same anyOf error and only do
+        # the prioritization in these cases. Can't think of a chart spec where this
+        # would not be the case but still allow for it below to not break anything.
+        parent = errors[0].parent
+        if (
+            parent is not None
+            and parent.validator == "anyOf"
+            # Use [1:] as don't have to check for first error as it was used
+            # above to define `parent`
+            and all(err.parent is parent for err in errors[1:])
+        ):
+            errors = [min(errors, key=lambda x: len(x.message))]
+    return errors
+
+
+def _deduplicate_by_message(errors: ValidationErrorList) -> ValidationErrorList:
+    """Deduplicate errors by message. This keeps the original order in case it was chosen intentionally."""
+    return list({e.message: e for e in errors}.values())
+
+
+def _subclasses(cls: type[Any]) -> Iterator[type[Any]]:
+    """Breadth-first sequence of all classes which inherit from cls."""
+    seen = set()
+    current_set = {cls}
+    while current_set:
+        seen |= current_set
+        current_set = set.union(*(set(cls.__subclasses__()) for cls in current_set))
+        for cls in current_set - seen:
+            yield cls
+
+
+def _from_array_like(obj: Iterable[Any], /) -> list[Any]:
+    try:
+        ser = nw.from_native(obj, strict=True, series_only=True)
+        return ser.to_list()
+    except TypeError:
+        return list(obj)
+
+
+def _todict(obj: Any, context: dict[str, Any] | None, np_opt: Any, pd_opt: Any) -> Any:  # noqa: C901
+    """Convert an object to a dict representation."""
+    if np_opt is not None:
+        np = np_opt
+        if isinstance(obj, np.ndarray):
+            return [_todict(v, context, np_opt, pd_opt) for v in obj]
+        elif isinstance(obj, np.number):
+            return float(obj)
+        elif isinstance(obj, np.datetime64):
+            result = str(obj)
+            if "T" not in result:
+                # See https://github.com/vega/altair/issues/1027 for why this is necessary.
+                result += "T00:00:00"
+            return result
+    if isinstance(obj, SchemaBase):
+        return obj.to_dict(validate=False, context=context)
+    elif isinstance(obj, (list, tuple)):
+        return [_todict(v, context, np_opt, pd_opt) for v in obj]
+    elif isinstance(obj, dict):
+        return {
+            k: _todict(v, context, np_opt, pd_opt)
+            for k, v in obj.items()
+            if v is not Undefined
+        }
+    elif (
+        hasattr(obj, "to_dict")
+        and (module_name := obj.__module__)
+        and module_name.startswith("altair")
+    ):
+        return obj.to_dict()
+    elif pd_opt is not None and isinstance(obj, pd_opt.Timestamp):
+        return pd_opt.Timestamp(obj).isoformat()
+    elif _is_iterable(obj, exclude=(str, bytes)):
+        return _todict(_from_array_like(obj), context, np_opt, pd_opt)
+    else:
+        return obj
+
+
+def _resolve_references(
+    schema: dict[str, Any], rootschema: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    """Resolve schema references until there is no $ref anymore in the top-level of the dictionary."""
+    if _use_referencing_library():
+        registry = _get_referencing_registry(rootschema or schema)
+        # Using a different variable name to show that this is not the
+        # jsonschema.RefResolver but instead a Resolver from the referencing
+        # library
+        referencing_resolver = registry.resolver()
+        while "$ref" in schema:
+            schema = referencing_resolver.lookup(
+                _VEGA_LITE_ROOT_URI + schema["$ref"]
+            ).contents
+    else:
+        resolver = jsonschema.RefResolver.from_schema(rootschema or schema)
+        while "$ref" in schema:
+            with resolver.resolving(schema["$ref"]) as resolved:
+                schema = resolved
+    return schema
+
+
+class SchemaValidationError(jsonschema.ValidationError):
+    """A wrapper for jsonschema.ValidationError with friendlier traceback."""
+
+    def __init__(self, obj: SchemaBase, err: jsonschema.ValidationError) -> None:
+        super().__init__(**err._contents())
+        self.obj = obj
+        self._errors: GroupedValidationErrors = getattr(
+            err, "_all_errors", {getattr(err, "json_path", _json_path(err)): [err]}
+        )
+        # This is the message from err
+        self._original_message = self.message
+        self.message = self._get_message()
+
+    def __str__(self) -> str:
+        return self.message
+
+    def _get_message(self) -> str:
+        def indent_second_line_onwards(message: str, indent: int = 4) -> str:
+            modified_lines: list[str] = []
+            for idx, line in enumerate(message.split("\n")):
+                if idx > 0 and len(line) > 0:
+                    line = " " * indent + line
+                modified_lines.append(line)
+            return "\n".join(modified_lines)
+
+        error_messages: list[str] = []
+        # Only show a maximum of 3 errors as else the final message returned by this
+        # method could get very long.
+        for errors in list(self._errors.values())[:3]:
+            error_messages.append(self._get_message_for_errors_group(errors))
+
+        message = ""
+        if len(error_messages) > 1:
+            error_messages = [
+                indent_second_line_onwards(f"Error {error_id}: {m}")
+                for error_id, m in enumerate(error_messages, start=1)
+            ]
+            message += "Multiple errors were found.\n\n"
+        message += "\n\n".join(error_messages)
+        return message
+
+    def _get_message_for_errors_group(
+        self,
+        errors: ValidationErrorList,
+    ) -> str:
+        if errors[0].validator == "additionalProperties":
+            # During development, we only found cases where an additionalProperties
+            # error was raised if that was the only error for the offending instance
+            # as identifiable by the json path. Therefore, we just check here the first
+            # error. However, other constellations might exist in which case
+            # this should be adapted so that other error messages are shown as well.
+            message = self._get_additional_properties_error_message(errors[0])
+        else:
+            message = self._get_default_error_message(errors=errors)
+
+        return message.strip()
+
+    def _get_additional_properties_error_message(
+        self,
+        error: jsonschema.exceptions.ValidationError,
+    ) -> str:
+        """Output all existing parameters when an unknown parameter is specified."""
+        altair_cls = self._get_altair_class_for_error(error)
+        param_dict_keys = inspect.signature(altair_cls).parameters.keys()
+        param_names_table = self._format_params_as_table(param_dict_keys)
+
+        # Error messages for these errors look like this:
+        # "Additional properties are not allowed ('unknown' was unexpected)"
+        # Line below extracts "unknown" from this string
+        parameter_name = error.message.split("('")[-1].split("'")[0]
+        message = f"""\
+`{altair_cls.__name__}` has no parameter named '{parameter_name}'
+
+Existing parameter names are:
+{param_names_table}
+See the help for `{altair_cls.__name__}` to read the full description of these parameters"""
+        return message
+
+    def _get_altair_class_for_error(
+        self, error: jsonschema.exceptions.ValidationError
+    ) -> type[SchemaBase]:
+        """
+        Try to get the lowest class possible in the chart hierarchy so it can be displayed in the error message.
+
+        This should lead to more informative error messages pointing the user closer to the source of the issue.
+        """
+        for prop_name in reversed(error.absolute_path):
+            # Check if str as e.g. first item can be a 0
+            if isinstance(prop_name, str):
+                potential_class_name = prop_name[0].upper() + prop_name[1:]
+                cls = getattr(vegalite, potential_class_name, None)
+                if cls is not None:
+                    break
+        else:
+            # Did not find a suitable class based on traversing the path so we fall
+            # back on the class of the top-level object which created
+            # the SchemaValidationError
+            cls = self.obj.__class__
+        return cls
+
+    @staticmethod
+    def _format_params_as_table(param_dict_keys: Iterable[str]) -> str:
+        """Format param names into a table so that they are easier to read."""
+        param_names: tuple[str, ...]
+        name_lengths: tuple[int, ...]
+        param_names, name_lengths = zip(
+            *[
+                (name, len(name))
+                for name in param_dict_keys
+                if name not in {"kwds", "self"}
+            ]
+        )
+        # Worst case scenario with the same longest param name in the same
+        # row for all columns
+        max_name_length = max(name_lengths)
+        max_column_width = 80
+        # Output a square table if not too big (since it is easier to read)
+        num_param_names = len(param_names)
+        square_columns = int(ceil(num_param_names**0.5))
+        columns = min(max_column_width // max_name_length, square_columns)
+
+        # Compute roughly equal column heights to evenly divide the param names
+        def split_into_equal_parts(n: int, p: int) -> list[int]:
+            return [n // p + 1] * (n % p) + [n // p] * (p - n % p)
+
+        column_heights = split_into_equal_parts(num_param_names, columns)
+
+        # Section the param names into columns and compute their widths
+        param_names_columns: list[tuple[str, ...]] = []
+        column_max_widths: list[int] = []
+        last_end_idx: int = 0
+        for ch in column_heights:
+            param_names_columns.append(param_names[last_end_idx : last_end_idx + ch])
+            column_max_widths.append(
+                max(len(param_name) for param_name in param_names_columns[-1])
+            )
+            last_end_idx = ch + last_end_idx
+
+        # Transpose the param name columns into rows to facilitate looping
+        param_names_rows: list[tuple[str, ...]] = []
+        for li in zip_longest(*param_names_columns, fillvalue=""):
+            param_names_rows.append(li)
+        # Build the table as a string by iterating over and formatting the rows
+        param_names_table: str = ""
+        for param_names_row in param_names_rows:
+            for num, param_name in enumerate(param_names_row):
+                # Set column width based on the longest param in the column
+                max_name_length_column = column_max_widths[num]
+                column_pad = 3
+                param_names_table += "{:<{}}".format(
+                    param_name, max_name_length_column + column_pad
+                )
+                # Insert newlines and spacing after the last element in each row
+                if num == (len(param_names_row) - 1):
+                    param_names_table += "\n"
+        return param_names_table
+
+    def _get_default_error_message(
+        self,
+        errors: ValidationErrorList,
+    ) -> str:
+        bullet_points: list[str] = []
+        errors_by_validator = _group_errors_by_validator(errors)
+        if "enum" in errors_by_validator:
+            for error in errors_by_validator["enum"]:
+                bullet_points.append(f"one of {error.validator_value}")
+
+        if "type" in errors_by_validator:
+            types = [f"'{err.validator_value}'" for err in errors_by_validator["type"]]
+            point = "of type "
+            if len(types) == 1:
+                point += types[0]
+            elif len(types) == 2:
+                point += f"{types[0]} or {types[1]}"
+            else:
+                point += ", ".join(types[:-1]) + f", or {types[-1]}"
+            bullet_points.append(point)
+
+        # It should not matter which error is specifically used as they are all
+        # about the same offending instance (i.e. invalid value), so we can just
+        # take the first one
+        error = errors[0]
+        # Add a summary line when parameters are passed an invalid value
+        # For example: "'asdf' is an invalid value for `stack`
+        message = f"'{error.instance}' is an invalid value"
+        if error.absolute_path:
+            message += f" for `{error.absolute_path[-1]}`"
+
+        # Add bullet points
+        if len(bullet_points) == 0:
+            message += ".\n\n"
+        elif len(bullet_points) == 1:
+            message += f". Valid values are {bullet_points[0]}.\n\n"
+        else:
+            # We don't use .capitalize below to make the first letter uppercase
+            # as that makes the rest of the message lowercase
+            bullet_points = [point[0].upper() + point[1:] for point in bullet_points]
+            message += ". Valid values are:\n\n"
+            message += "\n".join([f"- {point}" for point in bullet_points])
+            message += "\n\n"
+
+        # Add unformatted messages of any remaining errors which were not
+        # considered so far. This is not expected to be used but more exists
+        # as a fallback for cases which were not known during development.
+        it = (
+            "\n".join(e.message for e in errors)
+            for validator, errors in errors_by_validator.items()
+            if validator not in {"enum", "type"}
+        )
+        message += "".join(it)
+        return message
+
+
+class UndefinedType:
+    """A singleton object for marking undefined parameters."""
+
+    __instance = None
+
+    def __new__(cls, *args, **kwargs) -> Self:
+        if not isinstance(cls.__instance, cls):
+            cls.__instance = object.__new__(cls, *args, **kwargs)
+        return cls.__instance
+
+    def __repr__(self) -> str:
+        return "Undefined"
+
+
+Undefined = UndefinedType()
+T = TypeVar("T")
+Optional: TypeAlias = Union[T, UndefinedType]
+"""One of ``T`` specified type(s), or the ``Undefined`` singleton.
+
+Examples
+--------
+The parameters ``short``, ``long`` accept the same range of types::
+
+    # ruff: noqa: UP006, UP007
+    from altair.typing import Optional
+
+    def func_1(
+        short: Optional[str | bool | float | dict[str, Any] | SchemaBase] = Undefined,
+        long: Union[
+            str, bool, float, Dict[str, Any], SchemaBase, UndefinedType
+        ] = Undefined,
+    ): ...
+
+This is distinct from `typing.Optional <https://typing.readthedocs.io/en/latest/spec/historical.html#union-and-optional>`__.
+
+``altair.typing.Optional`` treats ``None`` like any other type::
+
+    # ruff: noqa: UP006, UP007
+    from altair.typing import Optional
+
+    def func_2(
+        short: Optional[str | float | dict[str, Any] | None | SchemaBase] = Undefined,
+        long: Union[
+            str, float, Dict[str, Any], None, SchemaBase, UndefinedType
+        ] = Undefined,
+    ): ...
+"""
+
+
+def is_undefined(obj: Any) -> TypeIs[UndefinedType]:
+    """
+    Type-safe singleton check for `UndefinedType`.
+
+    Notes
+    -----
+    - Using `obj is Undefined` does not narrow from `UndefinedType` in a union.
+        - Due to the assumption that other `UndefinedType`'s could exist.
+    - Current [typing spec advises](https://typing.readthedocs.io/en/latest/spec/concepts.html#support-for-singleton-types-in-unions) using an `Enum`.
+        - Otherwise, requires an explicit guard to inform the type checker.
+    """
+    return obj is Undefined
+
+
+@overload
+def _shallow_copy(obj: _CopyImpl) -> _CopyImpl: ...
+@overload
+def _shallow_copy(obj: Any) -> Any: ...
+def _shallow_copy(obj: _CopyImpl | Any) -> _CopyImpl | Any:
+    if isinstance(obj, SchemaBase):
+        return obj.copy(deep=False)
+    elif isinstance(obj, (list, dict)):
+        return obj.copy()
+    else:
+        return obj
+
+
+@overload
+def _deep_copy(obj: _CopyImpl, by_ref: set[str]) -> _CopyImpl: ...
+@overload
+def _deep_copy(obj: Any, by_ref: set[str]) -> Any: ...
+def _deep_copy(obj: _CopyImpl | Any, by_ref: set[str]) -> _CopyImpl | Any:
+    copy = partial(_deep_copy, by_ref=by_ref)
+    if isinstance(obj, SchemaBase):
+        if copier := getattr(obj, "__deepcopy__", None):
+            with debug_mode(False):
+                return copier(obj)
+        args = (copy(arg) for arg in obj._args)
+        kwds = {k: (copy(v) if k not in by_ref else v) for k, v in obj._kwds.items()}
+        with debug_mode(False):
+            return obj.__class__(*args, **kwds)
+    elif isinstance(obj, list):
+        return [copy(v) for v in obj]
+    elif isinstance(obj, dict):
+        return {k: (copy(v) if k not in by_ref else v) for k, v in obj.items()}
+    else:
+        return obj
+
+
+class SchemaBase:
+    """
+    Base class for schema wrappers.
+
+    Each derived class should set the _schema class attribute (and optionally
+    the _rootschema class attribute) which is used for validation.
+    """
+
+    _schema: ClassVar[dict[str, Any] | Any] = None
+    _rootschema: ClassVar[dict[str, Any] | None] = None
+    _class_is_valid_at_instantiation: ClassVar[bool] = True
+
+    def __init__(self, *args: Any, **kwds: Any) -> None:
+        # Two valid options for initialization, which should be handled by
+        # derived classes:
+        # - a single arg with no kwds, for, e.g. {'type': 'string'}
+        # - zero args with zero or more kwds for {'type': 'object'}
+        if self._schema is None:
+            msg = (
+                f"Cannot instantiate object of type {self.__class__}: "
+                "_schema class attribute is not defined."
+                ""
+            )
+            raise ValueError(msg)
+
+        if kwds:
+            assert len(args) == 0
+        else:
+            assert len(args) in {0, 1}
+
+        # use object.__setattr__ because we override setattr below.
+        object.__setattr__(self, "_args", args)
+        object.__setattr__(self, "_kwds", kwds)
+
+        if DEBUG_MODE and self._class_is_valid_at_instantiation:
+            self.to_dict(validate=True)
+
+    def copy(
+        self, deep: bool | Iterable[Any] = True, ignore: list[str] | None = None
+    ) -> Self:
+        """
+        Return a copy of the object.
+
+        Parameters
+        ----------
+        deep : boolean or list, optional
+            If True (default) then return a deep copy of all dict, list, and
+            SchemaBase objects within the object structure.
+            If False, then only copy the top object.
+            If a list or iterable, then only copy the listed attributes.
+        ignore : list, optional
+            A list of keys for which the contents should not be copied, but
+            only stored by reference.
+        """
+        if deep is True:
+            return cast("Self", _deep_copy(self, set(ignore) if ignore else set()))
+        with debug_mode(False):
+            copy = self.__class__(*self._args, **self._kwds)
+        if _is_iterable(deep):
+            for attr in deep:
+                copy[attr] = _shallow_copy(copy._get(attr))
+        return copy
+
+    def _get(self, attr, default=Undefined):
+        """Get an attribute, returning default if not present."""
+        attr = self._kwds.get(attr, Undefined)
+        if attr is Undefined:
+            attr = default
+        return attr
+
+    def __getattr__(self, attr):
+        # reminder: getattr is called after the normal lookups
+        if attr == "_kwds":
+            raise AttributeError()
+        if attr in self._kwds:
+            return self._kwds[attr]
+        else:
+            try:
+                _getattr = super().__getattr__  # pyright: ignore[reportAttributeAccessIssue]
+            except AttributeError:
+                _getattr = super().__getattribute__
+            return _getattr(attr)
+
+    def __setattr__(self, item, val) -> None:
+        self._kwds[item] = val
+
+    def __getitem__(self, item):
+        return self._kwds[item]
+
+    def __setitem__(self, item, val) -> None:
+        self._kwds[item] = val
+
+    def __repr__(self) -> str:
+        name = type(self).__name__
+        if kwds := self._kwds:
+            it = (f"{k}: {v!r}" for k, v in sorted(kwds.items()) if v is not Undefined)
+            args = ",\n".join(it).replace("\n", "\n  ")
+            LB, RB = "{", "}"
+            return f"{name}({LB}\n  {args}\n{RB})"
+        else:
+            return f"{name}({self._args[0]!r})"
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            type(self) is type(other)
+            and self._args == other._args
+            and self._kwds == other._kwds
+        )
+
+    def to_dict(
+        self,
+        validate: bool = True,
+        *,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Return a dictionary representation of the object.
+
+        Parameters
+        ----------
+        validate : bool, optional
+            If True (default), then validate the output dictionary
+            against the schema.
+        ignore : list[str], optional
+            A list of keys to ignore. It is usually not needed
+            to specify this argument as a user.
+        context : dict[str, Any], optional
+            A context dictionary. It is usually not needed
+            to specify this argument as a user.
+
+        Notes
+        -----
+        Technical: The ignore parameter will *not* be passed to child to_dict
+        function calls.
+
+        Returns
+        -------
+        dict
+            The dictionary representation of this object
+
+        Raises
+        ------
+        SchemaValidationError :
+            if validate=True and the dict does not conform to the schema
+        """
+        if context is None:
+            context = {}
+        if ignore is None:
+            ignore = []
+        # The following return the package only if it has already been
+        # imported - otherwise they return None. This is useful for
+        # isinstance checks - for example, if pandas has not been imported,
+        # then an object is definitely not a `pandas.Timestamp`.
+        pd_opt = sys.modules.get("pandas")
+        np_opt = sys.modules.get("numpy")
+
+        if self._args and not self._kwds:
+            result = _todict(
+                self._args[0], context=context, np_opt=np_opt, pd_opt=pd_opt
+            )
+        elif not self._args:
+            kwds = self._kwds.copy()
+            # parsed_shorthand is added by FieldChannelMixin.
+            # It's used below to replace shorthand with its long form equivalent
+            # parsed_shorthand is removed from context if it exists so that it is
+            # not passed to child to_dict function calls
+            parsed_shorthand = context.pop("parsed_shorthand", {})
+            # Prevent that pandas categorical data is automatically sorted
+            # when a non-ordinal data type is specifed manually
+            # or if the encoding channel does not support sorting
+            if "sort" in parsed_shorthand and (
+                "sort" not in kwds or kwds["type"] not in {"ordinal", Undefined}
+            ):
+                parsed_shorthand.pop("sort")
+
+            kwds.update(
+                {
+                    k: v
+                    for k, v in parsed_shorthand.items()
+                    if kwds.get(k, Undefined) is Undefined
+                }
+            )
+            kwds = {
+                k: v for k, v in kwds.items() if k not in {*list(ignore), "shorthand"}
+            }
+            if "mark" in kwds and isinstance(kwds["mark"], str):
+                kwds["mark"] = {"type": kwds["mark"]}
+            result = _todict(kwds, context=context, np_opt=np_opt, pd_opt=pd_opt)
+        else:
+            msg = (
+                f"{self.__class__} instance has both a value and properties : "
+                "cannot serialize to dict"
+            )
+            raise ValueError(msg)
+        if validate:
+            try:
+                self.validate(result)
+            except jsonschema.ValidationError as err:
+                # We do not raise `from err` as else the resulting
+                # traceback is very long as it contains part
+                # of the Vega-Lite schema. It would also first
+                # show the less helpful ValidationError instead of
+                # the more user friendly SchemaValidationError
+                raise SchemaValidationError(self, err) from None
+        return result
+
+    def to_json(
+        self,
+        validate: bool = True,
+        indent: int | str | None = 2,
+        sort_keys: bool = True,
+        *,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> str:
+        """
+        Emit the JSON representation for this object as a string.
+
+        Parameters
+        ----------
+        validate : bool, optional
+            If True (default), then validate the output dictionary
+            against the schema.
+        indent : int, optional
+            The number of spaces of indentation to use. The default is 2.
+        sort_keys : bool, optional
+            If True (default), sort keys in the output.
+        ignore : list[str], optional
+            A list of keys to ignore. It is usually not needed
+            to specify this argument as a user.
+        context : dict[str, Any], optional
+            A context dictionary. It is usually not needed
+            to specify this argument as a user.
+        **kwargs
+            Additional keyword arguments are passed to ``json.dumps()``
+
+        Notes
+        -----
+        Technical: The ignore parameter will *not* be passed to child to_dict
+        function calls.
+
+        Returns
+        -------
+        str
+            The JSON specification of the chart object.
+        """
+        if ignore is None:
+            ignore = []
+        if context is None:
+            context = {}
+        dct = self.to_dict(validate=validate, ignore=ignore, context=context)
+        return json.dumps(dct, indent=indent, sort_keys=sort_keys, **kwargs)
+
+    @classmethod
+    def _default_wrapper_classes(cls) -> Iterator[type[SchemaBase]]:
+        """Return the set of classes used within cls.from_dict()."""
+        return _subclasses(SchemaBase)
+
+    @classmethod
+    def from_dict(
+        cls: type[TSchemaBase], dct: dict[str, Any], validate: bool = True
+    ) -> TSchemaBase:
+        """
+        Construct class from a dictionary representation.
+
+        Parameters
+        ----------
+        dct : dictionary
+            The dict from which to construct the class
+        validate : boolean
+            If True (default), then validate the input against the schema.
+
+        Returns
+        -------
+        obj : Schema object
+            The wrapped schema
+
+        Raises
+        ------
+        jsonschema.ValidationError :
+            if validate=True and dct does not conform to the schema
+        """
+        if validate:
+            cls.validate(dct)
+        converter = _FromDict(cls._default_wrapper_classes())
+        return converter.from_dict(dct, cls)
+
+    @classmethod
+    def from_json(
+        cls,
+        json_string: str,
+        validate: bool = True,
+        **kwargs: Any,
+        # Type hints for this method would get rather complicated
+        # if we want to provide a more specific return type
+    ) -> ChartType:
+        """
+        Instantiate the object from a valid JSON string.
+
+        Parameters
+        ----------
+        json_string : string
+            The string containing a valid JSON chart specification.
+        validate : boolean
+            If True (default), then validate the input against the schema.
+        **kwargs :
+            Additional keyword arguments are passed to json.loads
+
+        Returns
+        -------
+        chart : Chart object
+            The altair Chart object built from the specification.
+        """
+        dct: dict[str, Any] = json.loads(json_string, **kwargs)
+        return cls.from_dict(dct, validate=validate)  # type: ignore[return-value]
+
+    @classmethod
+    def validate(
+        cls, instance: dict[str, Any], schema: dict[str, Any] | None = None
+    ) -> None:
+        """Validate the instance against the class schema in the context of the rootschema."""
+        if schema is None:
+            schema = cls._schema
+        # For the benefit of mypy
+        assert schema is not None
+        validate_jsonschema(instance, schema, rootschema=cls._rootschema or cls._schema)
+
+    @classmethod
+    def resolve_references(cls, schema: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Resolve references in the context of this object's schema or root schema."""
+        schema_to_pass = schema or cls._schema
+        # For the benefit of mypy
+        assert schema_to_pass is not None
+        return _resolve_references(
+            schema=schema_to_pass,
+            rootschema=(cls._rootschema or cls._schema or schema),
+        )
+
+    @classmethod
+    def validate_property(
+        cls, name: str, value: Any, schema: dict[str, Any] | None = None
+    ) -> None:
+        """Validate a property against property schema in the context of the rootschema."""
+        # The following return the package only if it has already been
+        # imported - otherwise they return None. This is useful for
+        # isinstance checks - for example, if pandas has not been imported,
+        # then an object is definitely not a `pandas.Timestamp`.
+        pd_opt = sys.modules.get("pandas")
+        np_opt = sys.modules.get("numpy")
+        value = _todict(value, context={}, np_opt=np_opt, pd_opt=pd_opt)
+        props = cls.resolve_references(schema or cls._schema).get("properties", {})
+        validate_jsonschema(
+            value, props.get(name, {}), rootschema=cls._rootschema or cls._schema
+        )
+
+    def __dir__(self) -> list[str]:
+        return sorted(chain(super().__dir__(), self._kwds))
+
+
+TSchemaBase = TypeVar("TSchemaBase", bound=SchemaBase)
+
+_CopyImpl = TypeVar("_CopyImpl", SchemaBase, Dict[Any, Any], List[Any])
+"""
+Types which have an implementation in ``SchemaBase.copy()``.
+
+All other types are returned **by reference**.
+"""
+
+
+def _is_dict(obj: Any | dict[Any, Any]) -> TypeIs[dict[Any, Any]]:
+    return isinstance(obj, dict)
+
+
+def _is_list(obj: Any | list[Any]) -> TypeIs[list[Any]]:
+    return isinstance(obj, list)
+
+
+def _is_iterable(
+    obj: Any, *, exclude: type | tuple[type, ...] = (str, bytes)
+) -> TypeIs[Iterable[Any]]:
+    return not isinstance(obj, exclude) and isinstance(obj, Iterable)
+
+
+def _passthrough(*args: Any, **kwds: Any) -> Any | dict[str, Any]:
+    return args[0] if args else kwds
+
+
+class _FromDict:
+    """
+    Class used to construct SchemaBase class hierarchies from a dict.
+
+    The primary purpose of using this class is to be able to build a hash table
+    that maps schemas to their wrapper classes. The candidate classes are
+    specified in the ``wrapper_classes`` positional-only argument to the constructor.
+    """
+
+    _hash_exclude_keys = ("definitions", "title", "description", "$schema", "id")
+
+    def __init__(self, wrapper_classes: Iterable[type[SchemaBase]], /) -> None:
+        # Create a mapping of a schema hash to a list of matching classes
+        # This lets us quickly determine the correct class to construct
+        self.class_dict: dict[int, list[type[SchemaBase]]] = defaultdict(list)
+        for tp in wrapper_classes:
+            if tp._schema is not None:
+                self.class_dict[self.hash_schema(tp._schema)].append(tp)
+
+    @classmethod
+    def hash_schema(cls, schema: dict[str, Any], use_json: bool = True) -> int:
+        """
+        Compute a python hash for a nested dictionary which properly handles dicts, lists, sets, and tuples.
+
+        At the top level, the function excludes from the hashed schema all keys
+        listed in `exclude_keys`.
+
+        This implements two methods: one based on conversion to JSON, and one based
+        on recursive conversions of unhashable to hashable types; the former seems
+        to be slightly faster in several benchmarks.
+        """
+        if cls._hash_exclude_keys and isinstance(schema, dict):
+            schema = {
+                key: val
+                for key, val in schema.items()
+                if key not in cls._hash_exclude_keys
+            }
+        if use_json:
+            s = json.dumps(schema, sort_keys=True)
+            return hash(s)
+        else:
+
+            def _freeze(val):
+                if isinstance(val, dict):
+                    return frozenset((k, _freeze(v)) for k, v in val.items())
+                elif isinstance(val, set):
+                    return frozenset(map(_freeze, val))
+                elif isinstance(val, (list, tuple)):
+                    return tuple(map(_freeze, val))
+                else:
+                    return val
+
+            return hash(_freeze(schema))
+
+    @overload
+    def from_dict(
+        self,
+        dct: TSchemaBase,
+        tp: None = ...,
+        schema: None = ...,
+        rootschema: None = ...,
+        default_class: Any = ...,
+    ) -> TSchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any] | list[dict[str, Any]],
+        tp: Any = ...,
+        schema: Any = ...,
+        rootschema: Any = ...,
+        default_class: type[TSchemaBase] = ...,  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> TSchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any],
+        tp: None = ...,
+        schema: dict[str, Any] = ...,
+        rootschema: None = ...,
+        default_class: Any = ...,
+    ) -> SchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any],
+        tp: type[TSchemaBase],
+        schema: None = ...,
+        rootschema: None = ...,
+        default_class: Any = ...,
+    ) -> TSchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any] | list[dict[str, Any]],
+        tp: type[TSchemaBase],
+        schema: dict[str, Any],
+        rootschema: dict[str, Any] | None = ...,
+        default_class: Any = ...,
+    ) -> Never: ...
+    def from_dict(
+        self,
+        dct: dict[str, Any] | list[dict[str, Any]] | TSchemaBase,
+        tp: type[TSchemaBase] | None = None,
+        schema: dict[str, Any] | None = None,
+        rootschema: dict[str, Any] | None = None,
+        default_class: Any = _passthrough,
+    ) -> TSchemaBase | SchemaBase:
+        """Construct an object from a dict representation."""
+        target_tp: Any
+        current_schema: dict[str, Any]
+        if isinstance(dct, SchemaBase):
+            return dct
+        elif tp is not None:
+            current_schema = tp._schema
+            root_schema: dict[str, Any] = rootschema or tp._rootschema or current_schema
+            target_tp = tp
+        elif schema is not None:
+            # If there are multiple matches, we use the first one in the dict.
+            # Our class dict is constructed breadth-first from top to bottom,
+            # so the first class that matches is the most general match.
+            current_schema = schema
+            root_schema = rootschema or current_schema
+            matches = self.class_dict[self.hash_schema(current_schema)]
+            target_tp = matches[0] if matches else default_class
+        else:
+            msg = "Must provide either `tp` or `schema`, but not both."
+            raise ValueError(msg)
+
+        from_dict = partial(self.from_dict, rootschema=root_schema)
+        # Can also return a list?
+        resolved = _resolve_references(current_schema, root_schema)
+        if "anyOf" in resolved or "oneOf" in resolved:
+            schemas = resolved.get("anyOf", []) + resolved.get("oneOf", [])
+            for possible in schemas:
+                try:
+                    validate_jsonschema(dct, possible, rootschema=root_schema)
+                except jsonschema.ValidationError:
+                    continue
+                else:
+                    return from_dict(dct, schema=possible, default_class=target_tp)
+
+        if _is_dict(dct):
+            # TODO: handle schemas for additionalProperties/patternProperties
+            props: dict[str, Any] = resolved.get("properties", {})
+            kwds = {
+                k: (from_dict(v, schema=props[k]) if k in props else v)
+                for k, v in dct.items()
+            }
+            return target_tp(**kwds)
+        elif _is_list(dct):
+            item_schema: dict[str, Any] = resolved.get("items", {})
+            return target_tp([from_dict(k, schema=item_schema) for k in dct])
+        else:
+            # NOTE: Unsure what is valid here
+            return target_tp(dct)
+
+
+class _PropertySetter:
+    def __init__(self, prop: str, schema: dict[str, Any]) -> None:
+        self.prop = prop
+        self.schema = schema
+
+    def __get__(self, obj, cls):
+        self.obj = obj
+        self.cls = cls
+        # The docs from the encoding class parameter (e.g. `bin` in X, Color,
+        # etc); this provides a general description of the parameter.
+        self.__doc__ = self.schema["description"].replace("__", "**")
+        property_name = f"{self.prop}"[0].upper() + f"{self.prop}"[1:]
+        if hasattr(vegalite, property_name):
+            altair_prop = getattr(vegalite, property_name)
+            # Add the docstring from the helper class (e.g. `BinParams`) so
+            # that all the parameter names of the helper class are included in
+            # the final docstring
+            parameter_index = altair_prop.__doc__.find("Parameters\n")
+            if parameter_index > -1:
+                self.__doc__ = (
+                    altair_prop.__doc__[:parameter_index].replace("    ", "")
+                    + self.__doc__
+                    + textwrap.dedent(
+                        f"\n\n    {altair_prop.__doc__[parameter_index:]}"
+                    )
+                )
+            # For short docstrings such as Aggregate, Stack, et
+            else:
+                self.__doc__ = (
+                    altair_prop.__doc__.replace("    ", "") + "\n" + self.__doc__
+                )
+            # Add signatures and tab completion for the method and parameter names
+            self.__signature__ = inspect.signature(altair_prop)
+            self.__wrapped__ = inspect.getfullargspec(altair_prop)
+            self.__name__ = altair_prop.__name__
+        else:
+            # It seems like bandPosition is the only parameter that doesn't
+            # have a helper class.
+            pass
+        return self
+
+    def __call__(self, *args: Any, **kwargs: Any):
+        obj = self.obj.copy()
+        # TODO: use schema to validate
+        obj[self.prop] = args[0] if args else kwargs
+        return obj
+
+
+def with_property_setters(cls: type[TSchemaBase]) -> type[TSchemaBase]:
+    """Decorator to add property setters to a Schema class."""
+    schema = cls.resolve_references()
+    for prop, propschema in schema.get("properties", {}).items():
+        setattr(cls, prop, _PropertySetter(prop, propschema))
+    return cls

videollama2/lib/python3.10/site-packages/altair/utils/selection.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, NewType
+
+# Type representing the "{selection}_store" dataset that corresponds to a
+# Vega-Lite selection
+Store = NewType("Store", List[Dict[str, Any]])
+
+
+@dataclass(frozen=True, eq=True)
+class IndexSelection:
+    """
+    Represents the state of an alt.selection_point() when neither the fields nor encodings arguments are specified.
+
+    The value field is a list of zero-based indices into the
+    selected dataset.
+
+    Note: These indices only apply to the input DataFrame
+    for charts that do not include aggregations (e.g. a scatter chart).
+    """
+
+    name: str
+    value: list[int]
+    store: Store
+
+    @staticmethod
+    def from_vega(name: str, signal: dict[str, dict] | None, store: Store):
+        """
+        Construct an IndexSelection from the raw Vega signal and dataset values.
+
+        Parameters
+        ----------
+        name: str
+            The selection's name
+        signal: dict or None
+            The value of the Vega signal corresponding to the selection
+        store: list
+            The value of the Vega dataset corresponding to the selection.
+            This dataset is named "{name}_store" in the Vega view.
+
+        Returns
+        -------
+        IndexSelection
+        """
+        if signal is None:
+            indices = []
+        else:
+            points = signal.get("vlPoint", {}).get("or", [])
+            indices = [p["_vgsid_"] - 1 for p in points]
+        return IndexSelection(name=name, value=indices, store=store)
+
+
+@dataclass(frozen=True, eq=True)
+class PointSelection:
+    """
+    Represents the state of an alt.selection_point() when the fields or encodings arguments are specified.
+
+    The value field is a list of dicts of the form:
+        [{"dim1": 1, "dim2": "A"}, {"dim1": 2, "dim2": "BB"}]
+
+    where "dim1" and "dim2" are dataset columns and the dict values
+    correspond to the specific selected values.
+    """
+
+    name: str
+    value: list[dict[str, Any]]
+    store: Store
+
+    @staticmethod
+    def from_vega(name: str, signal: dict[str, dict] | None, store: Store):
+        """
+        Construct a PointSelection from the raw Vega signal and dataset values.
+
+        Parameters
+        ----------
+        name: str
+            The selection's name
+        signal: dict or None
+            The value of the Vega signal corresponding to the selection
+        store: list
+            The value of the Vega dataset corresponding to the selection.
+            This dataset is named "{name}_store" in the Vega view.
+
+        Returns
+        -------
+        PointSelection
+        """
+        points = [] if signal is None else signal.get("vlPoint", {}).get("or", [])
+        return PointSelection(name=name, value=points, store=store)
+
+
+@dataclass(frozen=True, eq=True)
+class IntervalSelection:
+    """
+    Represents the state of an alt.selection_interval().
+
+    The value field is a dict of the form:
+        {"dim1": [0, 10], "dim2": ["A", "BB", "CCC"]}
+
+    where "dim1" and "dim2" are dataset columns and the dict values
+    correspond to the selected range.
+    """
+
+    name: str
+    value: dict[str, list]
+    store: Store
+
+    @staticmethod
+    def from_vega(name: str, signal: dict[str, list] | None, store: Store):
+        """
+        Construct an IntervalSelection from the raw Vega signal and dataset values.
+
+        Parameters
+        ----------
+        name: str
+            The selection's name
+        signal: dict or None
+            The value of the Vega signal corresponding to the selection
+        store: list
+            The value of the Vega dataset corresponding to the selection.
+            This dataset is named "{name}_store" in the Vega view.
+
+        Returns
+        -------
+        PointSelection
+        """
+        if signal is None:
+            signal = {}
+        return IntervalSelection(name=name, value=signal, store=store)

videollama2/lib/python3.10/site-packages/altair/utils/theme.py

@@ -0,0 +1,49 @@
+"""Utilities for registering and working with themes."""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Callable
+
+from .plugin_registry import PluginRegistry
+
+if sys.version_info >= (3, 11):
+    from typing import LiteralString
+else:
+    from typing_extensions import LiteralString
+
+if TYPE_CHECKING:
+    from altair.utils.plugin_registry import PluginEnabler
+    from altair.vegalite.v5.theme import AltairThemes, VegaThemes
+
+ThemeType = Callable[..., dict]
+
+
+class ThemeRegistry(PluginRegistry[ThemeType, dict]):
+    def enable(
+        self, name: LiteralString | AltairThemes | VegaThemes | None = None, **options
+    ) -> PluginEnabler:
+        """
+        Enable a theme by name.
+
+        This can be either called directly, or used as a context manager.
+
+        Parameters
+        ----------
+        name : string (optional)
+            The name of the theme to enable. If not specified, then use the
+            current active name.
+        **options :
+            Any additional parameters will be passed to the theme as keyword
+            arguments
+
+        Returns
+        -------
+        PluginEnabler:
+            An object that allows enable() to be used as a context manager
+
+        Notes
+        -----
+        Default `vega` themes can be previewed at https://vega.github.io/vega-themes/
+        """
+        return super().enable(name, **options)