Add files using upload-large-folder tool

.gitattributes

@@ -968,3 +968,4 @@ openflamingo/lib/python3.10/site-packages/3204bda914b7f2c6f497__mypyc.cpython-31
 parrot/lib/python3.10/html/__pycache__/entities.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 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/altair/utils/mimebundle.py

@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+import struct
+from typing import Any, Literal, cast, overload
+from typing_extensions import TypeAlias
+
+from ._importers import import_vl_convert, vl_version_for_vl_convert
+from .html import spec_to_html
+
+MimeBundleFormat: TypeAlias = Literal[
+    "html", "json", "png", "svg", "pdf", "vega", "vega-lite"
+]
+
+
+@overload
+def spec_to_mimebundle(
+    spec: dict[str, Any],
+    format: Literal["json", "vega-lite"],
+    mode: Literal["vega-lite"] | None = ...,
+    vega_version: str | None = ...,
+    vegaembed_version: str | None = ...,
+    vegalite_version: str | None = ...,
+    embed_options: dict[str, Any] | None = ...,
+    engine: Literal["vl-convert"] | None = ...,
+    **kwargs,
+) -> dict[str, dict[str, Any]]: ...
+@overload
+def spec_to_mimebundle(
+    spec: dict[str, Any],
+    format: Literal["html"],
+    mode: Literal["vega-lite"] | None = ...,
+    vega_version: str | None = ...,
+    vegaembed_version: str | None = ...,
+    vegalite_version: str | None = ...,
+    embed_options: dict[str, Any] | None = ...,
+    engine: Literal["vl-convert"] | None = ...,
+    **kwargs,
+) -> dict[str, str]: ...
+@overload
+def spec_to_mimebundle(
+    spec: dict[str, Any],
+    format: Literal["pdf", "svg", "vega"],
+    mode: Literal["vega-lite"] | None = ...,
+    vega_version: str | None = ...,
+    vegaembed_version: str | None = ...,
+    vegalite_version: str | None = ...,
+    embed_options: dict[str, Any] | None = ...,
+    engine: Literal["vl-convert"] | None = ...,
+    **kwargs,
+) -> dict[str, Any]: ...
+@overload
+def spec_to_mimebundle(
+    spec: dict[str, Any],
+    format: Literal["png"],
+    mode: Literal["vega-lite"] | None = ...,
+    vega_version: str | None = ...,
+    vegaembed_version: str | None = ...,
+    vegalite_version: str | None = ...,
+    embed_options: dict[str, Any] | None = ...,
+    engine: Literal["vl-convert"] | None = ...,
+    **kwargs,
+) -> tuple[dict[str, Any], dict[str, Any]]: ...
+def spec_to_mimebundle(
+    spec: dict[str, Any],
+    format: MimeBundleFormat,
+    mode: Literal["vega-lite"] | None = None,
+    vega_version: str | None = None,
+    vegaembed_version: str | None = None,
+    vegalite_version: str | None = None,
+    embed_options: dict[str, Any] | None = None,
+    engine: Literal["vl-convert"] | None = None,
+    **kwargs,
+) -> dict[str, Any] | tuple[dict[str, Any], dict[str, Any]]:
+    """
+    Convert a vega-lite specification to a mimebundle.
+
+    The mimebundle type is controlled by the ``format`` argument, which can be
+    one of the following ['html', 'json', 'png', 'svg', 'pdf', 'vega', 'vega-lite']
+
+    Parameters
+    ----------
+    spec : dict
+        a dictionary representing a vega-lite plot spec
+    format : string {'html', 'json', 'png', 'svg', 'pdf', 'vega', 'vega-lite'}
+        the file format to be saved.
+    mode : string {'vega-lite'}
+        The rendering mode.
+    vega_version : string
+        The version of vega.js to use
+    vegaembed_version : string
+        The version of vegaembed.js to use
+    vegalite_version : string
+        The version of vegalite.js to use. Only required if mode=='vega-lite'
+    embed_options : dict (optional)
+        The vegaEmbed options dictionary. Defaults to the embed options set with
+        alt.renderers.set_embed_options().
+        (See https://github.com/vega/vega-embed for details)
+    engine: string {'vl-convert'}
+        the conversion engine to use for 'png', 'svg', 'pdf', and 'vega' formats
+    **kwargs :
+        Additional arguments will be passed to the generating function
+
+    Returns
+    -------
+    output : dict
+        a mime-bundle representing the image
+
+    Note
+    ----
+    The png, svg, pdf, and vega outputs require the vl-convert package
+    """
+    # Local import to avoid circular ImportError
+    from altair import renderers
+    from altair.utils.display import compile_with_vegafusion, using_vegafusion
+
+    if mode != "vega-lite":
+        msg = "mode must be 'vega-lite'"
+        raise ValueError(msg)
+
+    internal_mode: Literal["vega-lite", "vega"] = mode
+    if using_vegafusion():
+        spec = compile_with_vegafusion(spec)
+        internal_mode = "vega"
+
+    # Default to the embed options set by alt.renderers.set_embed_options
+    if embed_options is None:
+        final_embed_options = renderers.options.get("embed_options", {})
+    else:
+        final_embed_options = embed_options
+
+    embed_options = preprocess_embed_options(final_embed_options)
+
+    if format in {"png", "svg", "pdf", "vega"}:
+        return _spec_to_mimebundle_with_engine(
+            spec,
+            cast(Literal["png", "svg", "pdf", "vega"], format),
+            internal_mode,
+            engine=engine,
+            format_locale=embed_options.get("formatLocale", None),
+            time_format_locale=embed_options.get("timeFormatLocale", None),
+            **kwargs,
+        )
+    elif format == "html":
+        html = spec_to_html(
+            spec,
+            mode=internal_mode,
+            vega_version=vega_version,
+            vegaembed_version=vegaembed_version,
+            vegalite_version=vegalite_version,
+            embed_options=embed_options,
+            **kwargs,
+        )
+        return {"text/html": html}
+    elif format == "vega-lite":
+        if vegalite_version is None:
+            msg = "Must specify vegalite_version"
+            raise ValueError(msg)
+        return {f"application/vnd.vegalite.v{vegalite_version[0]}+json": spec}
+    elif format == "json":
+        return {"application/json": spec}
+    else:
+        msg = (
+            "format must be one of "
+            "['html', 'json', 'png', 'svg', 'pdf', 'vega', 'vega-lite']"
+        )
+        raise ValueError(msg)
+
+
+def _spec_to_mimebundle_with_engine(
+    spec: dict,
+    format: Literal["png", "svg", "pdf", "vega"],
+    mode: Literal["vega-lite", "vega"],
+    format_locale: str | dict | None = None,
+    time_format_locale: str | dict | None = None,
+    **kwargs,
+) -> Any:
+    """
+    Helper for Vega-Lite to mimebundle conversions that require an engine.
+
+    Parameters
+    ----------
+    spec : dict
+        a dictionary representing a vega-lite plot spec
+    format : string {'png', 'svg', 'pdf', 'vega'}
+        the format of the mimebundle to be returned
+    mode : string {'vega-lite', 'vega'}
+        The rendering mode.
+    engine: string {'vl-convert'}
+        the conversion engine to use
+    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 arguments will be passed to the conversion function
+    """
+    # Normalize the engine string (if any) by lower casing
+    # and removing underscores and hyphens
+    engine = kwargs.pop("engine", None)
+    normalized_engine = _validate_normalize_engine(engine, format)
+
+    if normalized_engine == "vlconvert":
+        vlc = import_vl_convert()
+        vl_version = vl_version_for_vl_convert()
+        if format == "vega":
+            if mode == "vega":
+                vg = spec
+            else:
+                vg = vlc.vegalite_to_vega(spec, vl_version=vl_version)
+            return {"application/vnd.vega.v5+json": vg}
+        elif format == "svg":
+            if mode == "vega":
+                svg = vlc.vega_to_svg(
+                    spec,
+                    format_locale=format_locale,
+                    time_format_locale=time_format_locale,
+                )
+            else:
+                svg = vlc.vegalite_to_svg(
+                    spec,
+                    vl_version=vl_version,
+                    format_locale=format_locale,
+                    time_format_locale=time_format_locale,
+                )
+            return {"image/svg+xml": svg}
+        elif format == "png":
+            scale = kwargs.get("scale_factor", 1)
+            # The default ppi for a PNG file is 72
+            default_ppi = 72
+            ppi = kwargs.get("ppi", default_ppi)
+            if mode == "vega":
+                png = vlc.vega_to_png(
+                    spec,
+                    scale=scale,
+                    ppi=ppi,
+                    format_locale=format_locale,
+                    time_format_locale=time_format_locale,
+                )
+            else:
+                png = vlc.vegalite_to_png(
+                    spec,
+                    vl_version=vl_version,
+                    scale=scale,
+                    ppi=ppi,
+                    format_locale=format_locale,
+                    time_format_locale=time_format_locale,
+                )
+            factor = ppi / default_ppi
+            w, h = _pngxy(png)
+            return {"image/png": png}, {
+                "image/png": {"width": w / factor, "height": h / factor}
+            }
+        elif format == "pdf":
+            scale = kwargs.get("scale_factor", 1)
+            if mode == "vega":
+                pdf = vlc.vega_to_pdf(
+                    spec,
+                    scale=scale,
+                    format_locale=format_locale,
+                    time_format_locale=time_format_locale,
+                )
+            else:
+                pdf = vlc.vegalite_to_pdf(
+                    spec,
+                    vl_version=vl_version,
+                    scale=scale,
+                    format_locale=format_locale,
+                    time_format_locale=time_format_locale,
+                )
+            return {"application/pdf": pdf}
+        else:
+            # This should be validated above
+            # but raise exception for the sake of future development
+            msg = f"Unexpected format {format!r}"
+            raise ValueError(msg)
+    else:
+        # This should be validated above
+        # but raise exception for the sake of future development
+        msg = f"Unexpected normalized_engine {normalized_engine!r}"
+        raise ValueError(msg)
+
+
+def _validate_normalize_engine(
+    engine: Literal["vl-convert"] | None,
+    format: Literal["png", "svg", "pdf", "vega"],
+) -> str:
+    """
+    Helper to validate and normalize the user-provided engine.
+
+    engine : {None, 'vl-convert'}
+        the user-provided engine string
+    format : string {'png', 'svg', 'pdf', 'vega'}
+        the format of the mimebundle to be returned
+    """
+    # Try to import vl_convert
+    try:
+        vlc = import_vl_convert()
+    except ImportError:
+        vlc = None
+
+    # Normalize engine string by lower casing and removing underscores and hyphens
+    normalized_engine = (
+        None if engine is None else engine.lower().replace("-", "").replace("_", "")
+    )
+
+    # Validate or infer default value of normalized_engine
+    if normalized_engine == "vlconvert":
+        if vlc is None:
+            msg = "The 'vl-convert' conversion engine requires the vl-convert-python package"
+            raise ValueError(msg)
+    elif normalized_engine is None:
+        if vlc is not None:
+            normalized_engine = "vlconvert"
+        else:
+            msg = (
+                f"Saving charts in {format!r} format requires the vl-convert-python package: "
+                "see https://altair-viz.github.io/user_guide/saving_charts.html#png-svg-and-pdf-format"
+            )
+            raise ValueError(msg)
+    else:
+        msg = f"Invalid conversion engine {engine!r}. Expected vl-convert"
+        raise ValueError(msg)
+    return normalized_engine
+
+
+def _pngxy(data):
+    """
+    read the (width, height) from a PNG header.
+
+    Taken from IPython.display
+    """
+    ihdr = data.index(b"IHDR")
+    # next 8 bytes are width/height
+    return struct.unpack(">ii", data[ihdr + 4 : ihdr + 12])
+
+
+def preprocess_embed_options(embed_options: dict) -> dict:
+    """
+    Preprocess embed options to a form compatible with Vega Embed.
+
+    Parameters
+    ----------
+    embed_options : dict
+        The embed options dictionary to preprocess.
+
+    Returns
+    -------
+    embed_opts : dict
+        The preprocessed embed options dictionary.
+    """
+    embed_options = (embed_options or {}).copy()
+
+    # Convert locale strings to objects compatible with Vega Embed using vl-convert
+    format_locale = embed_options.get("formatLocale", None)
+    if isinstance(format_locale, str):
+        vlc = import_vl_convert()
+        embed_options["formatLocale"] = vlc.get_format_locale(format_locale)
+
+    time_format_locale = embed_options.get("timeFormatLocale", None)
+    if isinstance(time_format_locale, str):
+        vlc = import_vl_convert()
+        embed_options["timeFormatLocale"] = vlc.get_time_format_locale(
+            time_format_locale
+        )
+
+    return embed_options

videollama2/lib/python3.10/site-packages/altair/vegalite/__init__.py

@@ -0,0 +1,2 @@
+# ruff: noqa: F403
+from .v5 import *

videollama2/lib/python3.10/site-packages/altair/vegalite/api.py

@@ -0,0 +1,2 @@
+# ruff: noqa
+from .v5.api import *

videollama2/lib/python3.10/site-packages/altair/vegalite/data.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable, overload
+
+from altair.utils.core import sanitize_pandas_dataframe
+from altair.utils.data import DataTransformerRegistry as _DataTransformerRegistry
+from altair.utils.data import (
+    MaxRowsError,
+    check_data_type,
+    limit_rows,
+    sample,
+    to_csv,
+    to_json,
+    to_values,
+)
+
+if TYPE_CHECKING:
+    from altair.utils.data import DataType, ToValuesReturnType
+    from altair.utils.plugin_registry import PluginEnabler
+
+
+@overload
+def default_data_transformer(
+    data: None = ..., max_rows: int = ...
+) -> Callable[[DataType], ToValuesReturnType]: ...
+@overload
+def default_data_transformer(
+    data: DataType, max_rows: int = ...
+) -> ToValuesReturnType: ...
+def default_data_transformer(
+    data: DataType | None = None, max_rows: int = 5000
+) -> Callable[[DataType], ToValuesReturnType] | ToValuesReturnType:
+    if data is None:
+
+        def pipe(data: DataType, /) -> ToValuesReturnType:
+            data = limit_rows(data, max_rows=max_rows)
+            return to_values(data)
+
+        return pipe
+
+    else:
+        return to_values(limit_rows(data, max_rows=max_rows))
+
+
+class DataTransformerRegistry(_DataTransformerRegistry):
+    def disable_max_rows(self) -> PluginEnabler:
+        """Disable the MaxRowsError."""
+        options = self.options
+        if self.active in {"default", "vegafusion"}:
+            options = options.copy()
+            options["max_rows"] = None
+        return self.enable(**options)
+
+
+__all__ = (
+    "DataTransformerRegistry",
+    "MaxRowsError",
+    "check_data_type",
+    "default_data_transformer",
+    "limit_rows",
+    "sample",
+    "sanitize_pandas_dataframe",
+    "to_csv",
+    "to_json",
+    "to_values",
+)

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

@@ -0,0 +1,17 @@
+from altair.utils.display import (
+    DefaultRendererReturnType,
+    Displayable,
+    HTMLRenderer,
+    RendererRegistry,
+    default_renderer_base,
+    json_renderer_base,
+)
+
+__all__ = (
+    "DefaultRendererReturnType",
+    "Displayable",
+    "HTMLRenderer",
+    "RendererRegistry",
+    "default_renderer_base",
+    "json_renderer_base",
+)

videollama2/lib/python3.10/site-packages/altair/vegalite/schema.py

@@ -0,0 +1,4 @@
+"""Altair schema wrappers."""
+
+# ruff: noqa: F403
+from .v5.schema import *

videollama2/lib/python3.10/site-packages/altair/vegalite/v5/__init__.py

@@ -0,0 +1,24 @@
+# ruff: noqa: F401, F403
+from altair.expr.core import datum
+
+from .api import *
+from .compiler import vegalite_compilers
+from .data import (
+    MaxRowsError,
+    data_transformers,
+    default_data_transformer,
+    limit_rows,
+    sample,
+    to_csv,
+    to_json,
+    to_values,
+)
+from .display import (
+    VEGA_VERSION,
+    VEGAEMBED_VERSION,
+    VEGALITE_VERSION,
+    VegaLite,
+    renderers,
+)
+from .schema import *
+from .theme import themes

videollama2/lib/python3.10/site-packages/altair/vegalite/v5/compiler.py

@@ -0,0 +1,23 @@
+from typing import Final
+
+from altair.utils._importers import import_vl_convert
+from altair.utils.compiler import VegaLiteCompilerRegistry
+
+ENTRY_POINT_GROUP: Final = "altair.vegalite.v5.vegalite_compiler"
+vegalite_compilers = VegaLiteCompilerRegistry(entry_point_group=ENTRY_POINT_GROUP)
+
+
+def vl_convert_compiler(vegalite_spec: dict) -> dict:
+    """Vega-Lite to Vega compiler that uses vl-convert."""
+    from . import SCHEMA_VERSION
+
+    vlc = import_vl_convert()
+
+    # Compute vl-convert's vl_version string (of the form 'v5_8')
+    # from SCHEMA_VERSION (of the form 'v5.8.0')
+    vl_version = "_".join(SCHEMA_VERSION.split(".")[:2])
+    return vlc.vegalite_to_vega(vegalite_spec, vl_version=vl_version)
+
+
+vegalite_compilers.register("vl-convert", vl_convert_compiler)
+vegalite_compilers.enable("vl-convert")

videollama2/lib/python3.10/site-packages/altair/vegalite/v5/data.py

@@ -0,0 +1,41 @@
+from typing import Final
+
+from altair.utils._vegafusion_data import vegafusion_data_transformer
+from altair.vegalite.data import (
+    DataTransformerRegistry,
+    MaxRowsError,
+    default_data_transformer,
+    limit_rows,
+    sample,
+    to_csv,
+    to_json,
+    to_values,
+)
+
+# ==============================================================================
+# VegaLite 5 data transformers
+# ==============================================================================
+
+
+ENTRY_POINT_GROUP: Final = "altair.vegalite.v5.data_transformer"
+
+
+data_transformers = DataTransformerRegistry(entry_point_group=ENTRY_POINT_GROUP)
+data_transformers.register("default", default_data_transformer)
+data_transformers.register("json", to_json)
+# FIXME: `to_csv` cannot accept all `DataType` https://github.com/vega/altair/issues/3441
+data_transformers.register("csv", to_csv)  # type: ignore[arg-type]
+data_transformers.register("vegafusion", vegafusion_data_transformer)
+data_transformers.enable("default")
+
+
+__all__ = (
+    "MaxRowsError",
+    "default_data_transformer",
+    "limit_rows",
+    "sample",
+    "to_csv",
+    "to_json",
+    "to_values",
+    "vegafusion_data_transformer",
+)

vllm/lib/python3.10/site-packages/pandas/_config/__init__.py

@@ -0,0 +1,57 @@
+"""
+pandas._config is considered explicitly upstream of everything else in pandas,
+should have no intra-pandas dependencies.
+
+importing `dates` and `display` ensures that keys needed by _libs
+are initialized.
+"""
+__all__ = [
+    "config",
+    "detect_console_encoding",
+    "get_option",
+    "set_option",
+    "reset_option",
+    "describe_option",
+    "option_context",
+    "options",
+    "using_copy_on_write",
+    "warn_copy_on_write",
+]
+from pandas._config import config
+from pandas._config import dates  # pyright: ignore[reportUnusedImport]  # noqa: F401
+from pandas._config.config import (
+    _global_config,
+    describe_option,
+    get_option,
+    option_context,
+    options,
+    reset_option,
+    set_option,
+)
+from pandas._config.display import detect_console_encoding
+
+
+def using_copy_on_write() -> bool:
+    _mode_options = _global_config["mode"]
+    return (
+        _mode_options["copy_on_write"] is True
+        and _mode_options["data_manager"] == "block"
+    )
+
+
+def warn_copy_on_write() -> bool:
+    _mode_options = _global_config["mode"]
+    return (
+        _mode_options["copy_on_write"] == "warn"
+        and _mode_options["data_manager"] == "block"
+    )
+
+
+def using_nullable_dtypes() -> bool:
+    _mode_options = _global_config["mode"]
+    return _mode_options["nullable_dtypes"]
+
+
+def using_pyarrow_string_dtype() -> bool:
+    _mode_options = _global_config["future"]
+    return _mode_options["infer_string"]