diff --git a/.gitattributes b/.gitattributes index 26c26f8c697f3f1ae9afe18aad1ab29a7d79ed73..80af1248ff3c299e5512947366e8524d9c7481e2 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1955,3 +1955,5 @@ videollama2/lib/python3.10/site-packages/sklearn/preprocessing/_csr_polynomial_e llava_next/lib/python3.10/site-packages/scipy.libs/libscipy_openblas-c128ec02.so filter=lfs diff=lfs merge=lfs -text parrot/lib/python3.10/site-packages/scipy/special/_specfun.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text videollama2/lib/python3.10/site-packages/sklearn/preprocessing/__pycache__/_data.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text +vllm/lib/python3.10/site-packages/contourpy/_contourpy.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +vllm/lib/python3.10/site-packages/freetype/libfreetype.so filter=lfs diff=lfs merge=lfs -text diff --git a/vllm/lib/python3.10/site-packages/charset_normalizer-3.4.0.dist-info/LICENSE b/vllm/lib/python3.10/site-packages/charset_normalizer-3.4.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..ad82355b802d542e8443dc78b937fa36fdcc0ace --- /dev/null +++ b/vllm/lib/python3.10/site-packages/charset_normalizer-3.4.0.dist-info/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 TAHRI Ahmed R. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/vllm/lib/python3.10/site-packages/contourpy/__init__.py b/vllm/lib/python3.10/site-packages/contourpy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33c1f014b867cc069d532839b405c3f7696c5a22 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/__init__.py @@ -0,0 +1,285 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING + +import numpy as np + +from contourpy._contourpy import ( + ContourGenerator, + FillType, + LineType, + Mpl2005ContourGenerator, + Mpl2014ContourGenerator, + SerialContourGenerator, + ThreadedContourGenerator, + ZInterp, + max_threads, +) +from contourpy._version import __version__ +from contourpy.chunk import calc_chunk_sizes +from contourpy.convert import ( + convert_filled, + convert_lines, + convert_multi_filled, + convert_multi_lines, +) +from contourpy.dechunk import ( + dechunk_filled, + dechunk_lines, + dechunk_multi_filled, + dechunk_multi_lines, +) +from contourpy.enum_util import as_fill_type, as_line_type, as_z_interp + +if TYPE_CHECKING: + from typing import Any + + from numpy.typing import ArrayLike + + from ._contourpy import CoordinateArray, MaskArray + +__all__ = [ + "__version__", + "contour_generator", + "convert_filled", + "convert_lines", + "convert_multi_filled", + "convert_multi_lines", + "dechunk_filled", + "dechunk_lines", + "dechunk_multi_filled", + "dechunk_multi_lines", + "max_threads", + "FillType", + "LineType", + "ContourGenerator", + "Mpl2005ContourGenerator", + "Mpl2014ContourGenerator", + "SerialContourGenerator", + "ThreadedContourGenerator", + "ZInterp", +] + + +# Simple mapping of algorithm name to class name. +_class_lookup: dict[str, type[ContourGenerator]] = { + "mpl2005": Mpl2005ContourGenerator, + "mpl2014": Mpl2014ContourGenerator, + "serial": SerialContourGenerator, + "threaded": ThreadedContourGenerator, +} + + +def _remove_z_mask( + z: ArrayLike | np.ma.MaskedArray[Any, Any] | None, +) -> tuple[CoordinateArray, MaskArray | None]: + # Preserve mask if present. + z_array = np.ma.asarray(z, dtype=np.float64) # type: ignore[no-untyped-call] + z_masked = np.ma.masked_invalid(z_array, copy=False) # type: ignore[no-untyped-call] + + if np.ma.is_masked(z_masked): # type: ignore[no-untyped-call] + mask = np.ma.getmask(z_masked) # type: ignore[no-untyped-call] + else: + mask = None + + return np.ma.getdata(z_masked), mask # type: ignore[no-untyped-call] + + +def contour_generator( + x: ArrayLike | None = None, + y: ArrayLike | None = None, + z: ArrayLike | np.ma.MaskedArray[Any, Any] | None = None, + *, + name: str = "serial", + corner_mask: bool | None = None, + line_type: LineType | str | None = None, + fill_type: FillType | str | None = None, + chunk_size: int | tuple[int, int] | None = None, + chunk_count: int | tuple[int, int] | None = None, + total_chunk_count: int | None = None, + quad_as_tri: bool = False, + z_interp: ZInterp | str | None = ZInterp.Linear, + thread_count: int = 0, +) -> ContourGenerator: + """Create and return a :class:`~.ContourGenerator` object. + + The class and properties of the returned :class:`~.ContourGenerator` are determined by the + function arguments, with sensible defaults. + + Args: + x (array-like of shape (ny, nx) or (nx,), optional): The x-coordinates of the ``z`` values. + May be 2D with the same shape as ``z.shape``, or 1D with length ``nx = z.shape[1]``. + If not specified are assumed to be ``np.arange(nx)``. Must be ordered monotonically. + y (array-like of shape (ny, nx) or (ny,), optional): The y-coordinates of the ``z`` values. + May be 2D with the same shape as ``z.shape``, or 1D with length ``ny = z.shape[0]``. + If not specified are assumed to be ``np.arange(ny)``. Must be ordered monotonically. + z (array-like of shape (ny, nx), may be a masked array): The 2D gridded values to calculate + the contours of. May be a masked array, and any invalid values (``np.inf`` or + ``np.nan``) will also be masked out. + name (str): Algorithm name, one of ``"serial"``, ``"threaded"``, ``"mpl2005"`` or + ``"mpl2014"``, default ``"serial"``. + corner_mask (bool, optional): Enable/disable corner masking, which only has an effect if + ``z`` is a masked array. If ``False``, any quad touching a masked point is masked out. + If ``True``, only the triangular corners of quads nearest these points are always masked + out, other triangular corners comprising three unmasked points are contoured as usual. + If not specified, uses the default provided by the algorithm ``name``. + line_type (LineType or str, optional): The format of contour line data returned from calls + to :meth:`~.ContourGenerator.lines`, specified either as a :class:`~.LineType` or its + string equivalent such as ``"SeparateCode"``. + If not specified, uses the default provided by the algorithm ``name``. + The relationship between the :class:`~.LineType` enum and the data format returned from + :meth:`~.ContourGenerator.lines` is explained at :ref:`line_type`. + fill_type (FillType or str, optional): The format of filled contour data returned from calls + to :meth:`~.ContourGenerator.filled`, specified either as a :class:`~.FillType` or its + string equivalent such as ``"OuterOffset"``. + If not specified, uses the default provided by the algorithm ``name``. + The relationship between the :class:`~.FillType` enum and the data format returned from + :meth:`~.ContourGenerator.filled` is explained at :ref:`fill_type`. + chunk_size (int or tuple(int, int), optional): Chunk size in (y, x) directions, or the same + size in both directions if only one value is specified. + chunk_count (int or tuple(int, int), optional): Chunk count in (y, x) directions, or the + same count in both directions if only one value is specified. + total_chunk_count (int, optional): Total number of chunks. + quad_as_tri (bool): Enable/disable treating quads as 4 triangles, default ``False``. + If ``False``, a contour line within a quad is a straight line between points on two of + its edges. If ``True``, each full quad is divided into 4 triangles using a virtual point + at the centre (mean x, y of the corner points) and a contour line is piecewise linear + within those triangles. Corner-masked triangles are not affected by this setting, only + full unmasked quads. + z_interp (ZInterp or str, optional): How to interpolate ``z`` values when determining where + contour lines intersect the edges of quads and the ``z`` values of the central points of + quads, specified either as a :class:`~contourpy.ZInterp` or its string equivalent such + as ``"Log"``. Default is ``ZInterp.Linear``. + thread_count (int): Number of threads to use for contour calculation, default 0. Threads can + only be used with an algorithm ``name`` that supports threads (currently only + ``name="threaded"``) and there must be at least the same number of chunks as threads. + If ``thread_count=0`` and ``name="threaded"`` then it uses the maximum number of threads + as determined by the C++11 call ``std::thread::hardware_concurrency()``. If ``name`` is + something other than ``"threaded"`` then the ``thread_count`` will be set to ``1``. + + Return: + :class:`~.ContourGenerator`. + + Note: + A maximum of one of ``chunk_size``, ``chunk_count`` and ``total_chunk_count`` may be + specified. + + Warning: + The ``name="mpl2005"`` algorithm does not implement chunking for contour lines. + """ + x = np.asarray(x, dtype=np.float64) + y = np.asarray(y, dtype=np.float64) + z, mask = _remove_z_mask(z) + + # Check arguments: z. + if z.ndim != 2: + raise TypeError(f"Input z must be 2D, not {z.ndim}D") + + if z.shape[0] < 2 or z.shape[1] < 2: + raise TypeError(f"Input z must be at least a (2, 2) shaped array, but has shape {z.shape}") + + ny, nx = z.shape + + # Check arguments: x and y. + if x.ndim != y.ndim: + raise TypeError(f"Number of dimensions of x ({x.ndim}) and y ({y.ndim}) do not match") + + if x.ndim == 0: + x = np.arange(nx, dtype=np.float64) + y = np.arange(ny, dtype=np.float64) + x, y = np.meshgrid(x, y) + elif x.ndim == 1: + if len(x) != nx: + raise TypeError(f"Length of x ({len(x)}) must match number of columns in z ({nx})") + if len(y) != ny: + raise TypeError(f"Length of y ({len(y)}) must match number of rows in z ({ny})") + x, y = np.meshgrid(x, y) + elif x.ndim == 2: + if x.shape != z.shape: + raise TypeError(f"Shapes of x {x.shape} and z {z.shape} do not match") + if y.shape != z.shape: + raise TypeError(f"Shapes of y {y.shape} and z {z.shape} do not match") + else: + raise TypeError(f"Inputs x and y must be None, 1D or 2D, not {x.ndim}D") + + # Check mask shape just in case. + if mask is not None and mask.shape != z.shape: + raise ValueError("If mask is set it must be a 2D array with the same shape as z") + + # Check arguments: name. + if name not in _class_lookup: + raise ValueError(f"Unrecognised contour generator name: {name}") + + # Check arguments: chunk_size, chunk_count and total_chunk_count. + y_chunk_size, x_chunk_size = calc_chunk_sizes( + chunk_size, chunk_count, total_chunk_count, ny, nx) + + cls = _class_lookup[name] + + # Check arguments: corner_mask. + if corner_mask is None: + # Set it to default, which is True if the algorithm supports it. + corner_mask = cls.supports_corner_mask() + elif corner_mask and not cls.supports_corner_mask(): + raise ValueError(f"{name} contour generator does not support corner_mask=True") + + # Check arguments: line_type. + if line_type is None: + line_type = cls.default_line_type + else: + line_type = as_line_type(line_type) + + if not cls.supports_line_type(line_type): + raise ValueError(f"{name} contour generator does not support line_type {line_type}") + + # Check arguments: fill_type. + if fill_type is None: + fill_type = cls.default_fill_type + else: + fill_type = as_fill_type(fill_type) + + if not cls.supports_fill_type(fill_type): + raise ValueError(f"{name} contour generator does not support fill_type {fill_type}") + + # Check arguments: quad_as_tri. + if quad_as_tri and not cls.supports_quad_as_tri(): + raise ValueError(f"{name} contour generator does not support quad_as_tri=True") + + # Check arguments: z_interp. + if z_interp is None: + z_interp = ZInterp.Linear + else: + z_interp = as_z_interp(z_interp) + + if z_interp != ZInterp.Linear and not cls.supports_z_interp(): + raise ValueError(f"{name} contour generator does not support z_interp {z_interp}") + + # Check arguments: thread_count. + if thread_count not in (0, 1) and not cls.supports_threads(): + raise ValueError(f"{name} contour generator does not support thread_count {thread_count}") + + # Prepare args and kwargs for contour generator constructor. + args = [x, y, z, mask] + kwargs: dict[str, int | bool | LineType | FillType | ZInterp] = { + "x_chunk_size": x_chunk_size, + "y_chunk_size": y_chunk_size, + } + + if name not in ("mpl2005", "mpl2014"): + kwargs["line_type"] = line_type + kwargs["fill_type"] = fill_type + + if cls.supports_corner_mask(): + kwargs["corner_mask"] = corner_mask + + if cls.supports_quad_as_tri(): + kwargs["quad_as_tri"] = quad_as_tri + + if cls.supports_z_interp(): + kwargs["z_interp"] = z_interp + + if cls.supports_threads(): + kwargs["thread_count"] = thread_count + + # Create contour generator. + return cls(*args, **kwargs) diff --git a/vllm/lib/python3.10/site-packages/contourpy/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0cec71e3dbc63c2389261ab0d12bb4ffb88a707e Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/__pycache__/_version.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/_version.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2c48ca38088e02e61e8cc26a1dc96c4137d9f5b Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/_version.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/__pycache__/array.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/array.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1ceca2bf761cef37028736652844d2394d839367 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/array.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/__pycache__/chunk.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/chunk.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e170cc792c9137870389d680371f80f9895ddc1b Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/chunk.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/__pycache__/convert.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/convert.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce28edaf42aac526f4a3d8c38cf8e6a8c70c611a Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/convert.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/__pycache__/dechunk.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/dechunk.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..473d22cf1a3b393a27251d3873ab0056f38d19a6 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/dechunk.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/__pycache__/enum_util.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/enum_util.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..28c0f2a6f803c2649ca1511ff6e05b06ee0a7284 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/enum_util.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/__pycache__/typecheck.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/typecheck.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4f764d731abdd8c91b1ed4832dd6ef8f625c3d83 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/typecheck.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/__pycache__/types.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/types.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75a55cbc1b91f3ff2fdfc1cd4d265d9499d21a08 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/__pycache__/types.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/_contourpy.cpython-310-x86_64-linux-gnu.so b/vllm/lib/python3.10/site-packages/contourpy/_contourpy.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..b691940f7239a11e1f636a23c8d92db77b24e3ad --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/_contourpy.cpython-310-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1fc196718bf4b5e3c792f194d0786604efddfc2863dc1b3fe906202d12a320c2 +size 854312 diff --git a/vllm/lib/python3.10/site-packages/contourpy/_contourpy.pyi b/vllm/lib/python3.10/site-packages/contourpy/_contourpy.pyi new file mode 100644 index 0000000000000000000000000000000000000000..5f44eace52ab6df5f3d05443c89e17f363dd8174 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/_contourpy.pyi @@ -0,0 +1,199 @@ +from typing import ClassVar, NoReturn, TypeAlias + +import numpy as np +import numpy.typing as npt + +import contourpy._contourpy as cpy + +# Input numpy array types, the same as in common.h +CoordinateArray: TypeAlias = npt.NDArray[np.float64] +MaskArray: TypeAlias = npt.NDArray[np.bool_] +LevelArray: TypeAlias = npt.ArrayLike + +# Output numpy array types, the same as in common.h +PointArray: TypeAlias = npt.NDArray[np.float64] +CodeArray: TypeAlias = npt.NDArray[np.uint8] +OffsetArray: TypeAlias = npt.NDArray[np.uint32] + +# Types returned from filled() +FillReturn_OuterCode: TypeAlias = tuple[list[PointArray], list[CodeArray]] +FillReturn_OuterOffset: TypeAlias = tuple[list[PointArray], list[OffsetArray]] +FillReturn_ChunkCombinedCode: TypeAlias = tuple[list[PointArray | None], list[CodeArray | None]] +FillReturn_ChunkCombinedOffset: TypeAlias = tuple[list[PointArray | None], list[OffsetArray | None]] +FillReturn_ChunkCombinedCodeOffset: TypeAlias = tuple[list[PointArray | None], list[CodeArray | None], list[OffsetArray | None]] +FillReturn_ChunkCombinedOffsetOffset: TypeAlias = tuple[list[PointArray | None], list[OffsetArray | None], list[OffsetArray | None]] +FillReturn_Chunk: TypeAlias = FillReturn_ChunkCombinedCode | FillReturn_ChunkCombinedOffset | FillReturn_ChunkCombinedCodeOffset | FillReturn_ChunkCombinedOffsetOffset +FillReturn: TypeAlias = FillReturn_OuterCode | FillReturn_OuterOffset | FillReturn_Chunk + +# Types returned from lines() +LineReturn_Separate: TypeAlias = list[PointArray] +LineReturn_SeparateCode: TypeAlias = tuple[list[PointArray], list[CodeArray]] +LineReturn_ChunkCombinedCode: TypeAlias = tuple[list[PointArray | None], list[CodeArray | None]] +LineReturn_ChunkCombinedOffset: TypeAlias = tuple[list[PointArray | None], list[OffsetArray | None]] +LineReturn_ChunkCombinedNan: TypeAlias = tuple[list[PointArray | None]] +LineReturn_Chunk: TypeAlias = LineReturn_ChunkCombinedCode | LineReturn_ChunkCombinedOffset | LineReturn_ChunkCombinedNan +LineReturn: TypeAlias = LineReturn_Separate | LineReturn_SeparateCode | LineReturn_Chunk + + +NDEBUG: int +__version__: str + +class FillType: + ChunkCombinedCode: ClassVar[cpy.FillType] + ChunkCombinedCodeOffset: ClassVar[cpy.FillType] + ChunkCombinedOffset: ClassVar[cpy.FillType] + ChunkCombinedOffsetOffset: ClassVar[cpy.FillType] + OuterCode: ClassVar[cpy.FillType] + OuterOffset: ClassVar[cpy.FillType] + __members__: ClassVar[dict[str, cpy.FillType]] + def __eq__(self, other: object) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: object) -> bool: ... + def __setstate__(self, state: int) -> NoReturn: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + +class LineType: + ChunkCombinedCode: ClassVar[cpy.LineType] + ChunkCombinedNan: ClassVar[cpy.LineType] + ChunkCombinedOffset: ClassVar[cpy.LineType] + Separate: ClassVar[cpy.LineType] + SeparateCode: ClassVar[cpy.LineType] + __members__: ClassVar[dict[str, cpy.LineType]] + def __eq__(self, other: object) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: object) -> bool: ... + def __setstate__(self, state: int) -> NoReturn: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + +class ZInterp: + Linear: ClassVar[cpy.ZInterp] + Log: ClassVar[cpy.ZInterp] + __members__: ClassVar[dict[str, cpy.ZInterp]] + def __eq__(self, other: object) -> bool: ... + def __getstate__(self) -> int: ... + def __hash__(self) -> int: ... + def __index__(self) -> int: ... + def __init__(self, value: int) -> None: ... + def __int__(self) -> int: ... + def __ne__(self, other: object) -> bool: ... + def __setstate__(self, state: int) -> NoReturn: ... + @property + def name(self) -> str: ... + @property + def value(self) -> int: ... + +def max_threads() -> int: ... + +class ContourGenerator: + def create_contour(self, level: float) -> LineReturn: ... + def create_filled_contour(self, lower_level: float, upper_level: float) -> FillReturn: ... + def filled(self, lower_level: float, upper_level: float) -> FillReturn: ... + def lines(self, level: float) -> LineReturn: ... + def multi_filled(self, levels: LevelArray) -> list[FillReturn]: ... + def multi_lines(self, levels: LevelArray) -> list[LineReturn]: ... + @staticmethod + def supports_corner_mask() -> bool: ... + @staticmethod + def supports_fill_type(fill_type: FillType) -> bool: ... + @staticmethod + def supports_line_type(line_type: LineType) -> bool: ... + @staticmethod + def supports_quad_as_tri() -> bool: ... + @staticmethod + def supports_threads() -> bool: ... + @staticmethod + def supports_z_interp() -> bool: ... + @property + def chunk_count(self) -> tuple[int, int]: ... + @property + def chunk_size(self) -> tuple[int, int]: ... + @property + def corner_mask(self) -> bool: ... + @property + def fill_type(self) -> FillType: ... + @property + def line_type(self) -> LineType: ... + @property + def quad_as_tri(self) -> bool: ... + @property + def thread_count(self) -> int: ... + @property + def z_interp(self) -> ZInterp: ... + default_fill_type: cpy.FillType + default_line_type: cpy.LineType + +class Mpl2005ContourGenerator(ContourGenerator): + def __init__( + self, + x: CoordinateArray, + y: CoordinateArray, + z: CoordinateArray, + mask: MaskArray, + *, + x_chunk_size: int = 0, + y_chunk_size: int = 0, + ) -> None: ... + +class Mpl2014ContourGenerator(ContourGenerator): + def __init__( + self, + x: CoordinateArray, + y: CoordinateArray, + z: CoordinateArray, + mask: MaskArray, + *, + corner_mask: bool, + x_chunk_size: int = 0, + y_chunk_size: int = 0, + ) -> None: ... + +class SerialContourGenerator(ContourGenerator): + def __init__( + self, + x: CoordinateArray, + y: CoordinateArray, + z: CoordinateArray, + mask: MaskArray, + *, + corner_mask: bool, + line_type: LineType, + fill_type: FillType, + quad_as_tri: bool, + z_interp: ZInterp, + x_chunk_size: int = 0, + y_chunk_size: int = 0, + ) -> None: ... + def _write_cache(self) -> NoReturn: ... + +class ThreadedContourGenerator(ContourGenerator): + def __init__( + self, + x: CoordinateArray, + y: CoordinateArray, + z: CoordinateArray, + mask: MaskArray, + *, + corner_mask: bool, + line_type: LineType, + fill_type: FillType, + quad_as_tri: bool, + z_interp: ZInterp, + x_chunk_size: int = 0, + y_chunk_size: int = 0, + thread_count: int = 0, + ) -> None: ... + def _write_cache(self) -> None: ... diff --git a/vllm/lib/python3.10/site-packages/contourpy/_version.py b/vllm/lib/python3.10/site-packages/contourpy/_version.py new file mode 100644 index 0000000000000000000000000000000000000000..9c73af26be70465839a5f43818dbab3f5c35571f --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/_version.py @@ -0,0 +1 @@ +__version__ = "1.3.1" diff --git a/vllm/lib/python3.10/site-packages/contourpy/array.py b/vllm/lib/python3.10/site-packages/contourpy/array.py new file mode 100644 index 0000000000000000000000000000000000000000..a7054fae1dc2f39b2dc6789e60818b1dd9b49c55 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/array.py @@ -0,0 +1,261 @@ +from __future__ import annotations + +from itertools import chain, pairwise +from typing import TYPE_CHECKING + +import numpy as np + +from contourpy.typecheck import check_code_array, check_offset_array, check_point_array +from contourpy.types import CLOSEPOLY, LINETO, MOVETO, code_dtype, offset_dtype, point_dtype + +if TYPE_CHECKING: + import contourpy._contourpy as cpy + + +def codes_from_offsets(offsets: cpy.OffsetArray) -> cpy.CodeArray: + """Determine codes from offsets, assuming they all correspond to closed polygons. + """ + check_offset_array(offsets) + + n = offsets[-1] + codes = np.full(n, LINETO, dtype=code_dtype) + codes[offsets[:-1]] = MOVETO + codes[offsets[1:] - 1] = CLOSEPOLY + return codes + + +def codes_from_offsets_and_points( + offsets: cpy.OffsetArray, + points: cpy.PointArray, +) -> cpy.CodeArray: + """Determine codes from offsets and points, using the equality of the start and end points of + each line to determine if lines are closed or not. + """ + check_offset_array(offsets) + check_point_array(points) + + codes = np.full(len(points), LINETO, dtype=code_dtype) + codes[offsets[:-1]] = MOVETO + + end_offsets = offsets[1:] - 1 + closed = np.all(points[offsets[:-1]] == points[end_offsets], axis=1) + codes[end_offsets[closed]] = CLOSEPOLY + + return codes + + +def codes_from_points(points: cpy.PointArray) -> cpy.CodeArray: + """Determine codes for a single line, using the equality of the start and end points to + determine if the line is closed or not. + """ + check_point_array(points) + + n = len(points) + codes = np.full(n, LINETO, dtype=code_dtype) + codes[0] = MOVETO + if np.all(points[0] == points[-1]): + codes[-1] = CLOSEPOLY + return codes + + +def concat_codes(list_of_codes: list[cpy.CodeArray]) -> cpy.CodeArray: + """Concatenate a list of codes arrays into a single code array. + """ + if not list_of_codes: + raise ValueError("Empty list passed to concat_codes") + + return np.concatenate(list_of_codes, dtype=code_dtype) + + +def concat_codes_or_none(list_of_codes_or_none: list[cpy.CodeArray | None]) -> cpy.CodeArray | None: + """Concatenate a list of codes arrays or None into a single code array or None. + """ + list_of_codes = [codes for codes in list_of_codes_or_none if codes is not None] + if list_of_codes: + return concat_codes(list_of_codes) + else: + return None + + +def concat_offsets(list_of_offsets: list[cpy.OffsetArray]) -> cpy.OffsetArray: + """Concatenate a list of offsets arrays into a single offset array. + """ + if not list_of_offsets: + raise ValueError("Empty list passed to concat_offsets") + + n = len(list_of_offsets) + cumulative = np.cumsum([offsets[-1] for offsets in list_of_offsets], dtype=offset_dtype) + ret: cpy.OffsetArray = np.concatenate( + (list_of_offsets[0], *(list_of_offsets[i+1][1:] + cumulative[i] for i in range(n-1))), + dtype=offset_dtype, + ) + return ret + + +def concat_offsets_or_none( + list_of_offsets_or_none: list[cpy.OffsetArray | None], +) -> cpy.OffsetArray | None: + """Concatenate a list of offsets arrays or None into a single offset array or None. + """ + list_of_offsets = [offsets for offsets in list_of_offsets_or_none if offsets is not None] + if list_of_offsets: + return concat_offsets(list_of_offsets) + else: + return None + + +def concat_points(list_of_points: list[cpy.PointArray]) -> cpy.PointArray: + """Concatenate a list of point arrays into a single point array. + """ + if not list_of_points: + raise ValueError("Empty list passed to concat_points") + + return np.concatenate(list_of_points, dtype=point_dtype) + + +def concat_points_or_none( + list_of_points_or_none: list[cpy.PointArray | None], +) -> cpy.PointArray | None: + """Concatenate a list of point arrays or None into a single point array or None. + """ + list_of_points = [points for points in list_of_points_or_none if points is not None] + if list_of_points: + return concat_points(list_of_points) + else: + return None + + +def concat_points_or_none_with_nan( + list_of_points_or_none: list[cpy.PointArray | None], +) -> cpy.PointArray | None: + """Concatenate a list of points or None into a single point array or None, with NaNs used to + separate each line. + """ + list_of_points = [points for points in list_of_points_or_none if points is not None] + if list_of_points: + return concat_points_with_nan(list_of_points) + else: + return None + + +def concat_points_with_nan(list_of_points: list[cpy.PointArray]) -> cpy.PointArray: + """Concatenate a list of points into a single point array with NaNs used to separate each line. + """ + if not list_of_points: + raise ValueError("Empty list passed to concat_points_with_nan") + + if len(list_of_points) == 1: + return list_of_points[0] + else: + nan_spacer = np.full((1, 2), np.nan, dtype=point_dtype) + list_of_points = [list_of_points[0], + *list(chain(*((nan_spacer, x) for x in list_of_points[1:])))] + return concat_points(list_of_points) + + +def insert_nan_at_offsets(points: cpy.PointArray, offsets: cpy.OffsetArray) -> cpy.PointArray: + """Insert NaNs into a point array at locations specified by an offset array. + """ + check_point_array(points) + check_offset_array(offsets) + + if len(offsets) <= 2: + return points + else: + nan_spacer = np.array([np.nan, np.nan], dtype=point_dtype) + # Convert offsets to int64 to avoid numpy error when mixing signed and unsigned ints. + return np.insert(points, offsets[1:-1].astype(np.int64), nan_spacer, axis=0) + + +def offsets_from_codes(codes: cpy.CodeArray) -> cpy.OffsetArray: + """Determine offsets from codes using locations of MOVETO codes. + """ + check_code_array(codes) + + return np.append(np.nonzero(codes == MOVETO)[0], len(codes)).astype(offset_dtype) + + +def offsets_from_lengths(list_of_points: list[cpy.PointArray]) -> cpy.OffsetArray: + """Determine offsets from lengths of point arrays. + """ + if not list_of_points: + raise ValueError("Empty list passed to offsets_from_lengths") + + return np.cumsum([0] + [len(line) for line in list_of_points], dtype=offset_dtype) + + +def outer_offsets_from_list_of_codes(list_of_codes: list[cpy.CodeArray]) -> cpy.OffsetArray: + """Determine outer offsets from codes using locations of MOVETO codes. + """ + if not list_of_codes: + raise ValueError("Empty list passed to outer_offsets_from_list_of_codes") + + return np.cumsum([0] + [np.count_nonzero(codes == MOVETO) for codes in list_of_codes], + dtype=offset_dtype) + + +def outer_offsets_from_list_of_offsets(list_of_offsets: list[cpy.OffsetArray]) -> cpy.OffsetArray: + """Determine outer offsets from a list of offsets. + """ + if not list_of_offsets: + raise ValueError("Empty list passed to outer_offsets_from_list_of_offsets") + + return np.cumsum([0] + [len(offsets)-1 for offsets in list_of_offsets], dtype=offset_dtype) + + +def remove_nan(points: cpy.PointArray) -> tuple[cpy.PointArray, cpy.OffsetArray]: + """Remove NaN from a points array, also return the offsets corresponding to the NaN removed. + """ + check_point_array(points) + + nan_offsets = np.nonzero(np.isnan(points[:, 0]))[0] + if len(nan_offsets) == 0: + return points, np.array([0, len(points)], dtype=offset_dtype) + else: + points = np.delete(points, nan_offsets, axis=0) + nan_offsets -= np.arange(len(nan_offsets)) + offsets: cpy.OffsetArray = np.empty(len(nan_offsets)+2, dtype=offset_dtype) + offsets[0] = 0 + offsets[1:-1] = nan_offsets + offsets[-1] = len(points) + return points, offsets + + +def split_codes_by_offsets(codes: cpy.CodeArray, offsets: cpy.OffsetArray) -> list[cpy.CodeArray]: + """Split a code array at locations specified by an offset array into a list of code arrays. + """ + check_code_array(codes) + check_offset_array(offsets) + + if len(offsets) > 2: + return np.split(codes, offsets[1:-1]) + else: + return [codes] + + +def split_points_by_offsets( + points: cpy.PointArray, + offsets: cpy.OffsetArray, +) -> list[cpy.PointArray]: + """Split a point array at locations specified by an offset array into a list of point arrays. + """ + check_point_array(points) + check_offset_array(offsets) + + if len(offsets) > 2: + return np.split(points, offsets[1:-1]) + else: + return [points] + + +def split_points_at_nan(points: cpy.PointArray) -> list[cpy.PointArray]: + """Split a points array at NaNs into a list of point arrays. + """ + check_point_array(points) + + nan_offsets = np.nonzero(np.isnan(points[:, 0]))[0] + if len(nan_offsets) == 0: + return [points] + else: + nan_offsets = np.concatenate(([-1], nan_offsets, [len(points)])) + return [points[s+1:e] for s, e in pairwise(nan_offsets)] diff --git a/vllm/lib/python3.10/site-packages/contourpy/chunk.py b/vllm/lib/python3.10/site-packages/contourpy/chunk.py new file mode 100644 index 0000000000000000000000000000000000000000..94fded1b161d64adb23748b067630370d8fa2f3c --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/chunk.py @@ -0,0 +1,95 @@ +from __future__ import annotations + +import math + + +def calc_chunk_sizes( + chunk_size: int | tuple[int, int] | None, + chunk_count: int | tuple[int, int] | None, + total_chunk_count: int | None, + ny: int, + nx: int, +) -> tuple[int, int]: + """Calculate chunk sizes. + + Args: + chunk_size (int or tuple(int, int), optional): Chunk size in (y, x) directions, or the same + size in both directions if only one is specified. Cannot be negative. + chunk_count (int or tuple(int, int), optional): Chunk count in (y, x) directions, or the + same count in both directions if only one is specified. If less than 1, set to 1. + total_chunk_count (int, optional): Total number of chunks. If less than 1, set to 1. + ny (int): Number of grid points in y-direction. + nx (int): Number of grid points in x-direction. + + Return: + tuple(int, int): Chunk sizes (y_chunk_size, x_chunk_size). + + Note: + Zero or one of ``chunk_size``, ``chunk_count`` and ``total_chunk_count`` should be + specified. + """ + if sum([chunk_size is not None, chunk_count is not None, total_chunk_count is not None]) > 1: + raise ValueError("Only one of chunk_size, chunk_count and total_chunk_count should be set") + + if nx < 2 or ny < 2: + raise ValueError(f"(ny, nx) must be at least (2, 2), not ({ny}, {nx})") + + if total_chunk_count is not None: + max_chunk_count = (nx-1)*(ny-1) + total_chunk_count = min(max(total_chunk_count, 1), max_chunk_count) + if total_chunk_count == 1: + chunk_size = 0 + elif total_chunk_count == max_chunk_count: + chunk_size = (1, 1) + else: + factors = two_factors(total_chunk_count) + if ny > nx: + chunk_count = factors + else: + chunk_count = (factors[1], factors[0]) + + if chunk_count is not None: + if isinstance(chunk_count, tuple): + y_chunk_count, x_chunk_count = chunk_count + else: + y_chunk_count = x_chunk_count = chunk_count + x_chunk_count = min(max(x_chunk_count, 1), nx-1) + y_chunk_count = min(max(y_chunk_count, 1), ny-1) + chunk_size = (math.ceil((ny-1) / y_chunk_count), math.ceil((nx-1) / x_chunk_count)) + + if chunk_size is None: + y_chunk_size = x_chunk_size = 0 + elif isinstance(chunk_size, tuple): + y_chunk_size, x_chunk_size = chunk_size + else: + y_chunk_size = x_chunk_size = chunk_size + + if x_chunk_size < 0 or y_chunk_size < 0: + raise ValueError("chunk_size cannot be negative") + + return y_chunk_size, x_chunk_size + + +def two_factors(n: int) -> tuple[int, int]: + """Split an integer into two integer factors. + + The two factors will be as close as possible to the sqrt of n, and are returned in decreasing + order. Worst case returns (n, 1). + + Args: + n (int): The integer to factorize, must be positive. + + Return: + tuple(int, int): The two factors of n, in decreasing order. + """ + if n < 0: + raise ValueError(f"two_factors expects positive integer not {n}") + + i = math.ceil(math.sqrt(n)) + while n % i != 0: + i -= 1 + j = n // i + if i > j: + return i, j + else: + return j, i diff --git a/vllm/lib/python3.10/site-packages/contourpy/convert.py b/vllm/lib/python3.10/site-packages/contourpy/convert.py new file mode 100644 index 0000000000000000000000000000000000000000..ebdb1af8bf2f9b30c2d177dce9adf876dcb32835 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/convert.py @@ -0,0 +1,621 @@ +from __future__ import annotations + +from itertools import pairwise +from typing import TYPE_CHECKING, cast + +import numpy as np + +from contourpy._contourpy import FillType, LineType +import contourpy.array as arr +from contourpy.enum_util import as_fill_type, as_line_type +from contourpy.typecheck import check_filled, check_lines +from contourpy.types import MOVETO, offset_dtype + +if TYPE_CHECKING: + import contourpy._contourpy as cpy + + +def _convert_filled_from_OuterCode( + filled: cpy.FillReturn_OuterCode, + fill_type_to: FillType, +) -> cpy.FillReturn: + if fill_type_to == FillType.OuterCode: + return filled + elif fill_type_to == FillType.OuterOffset: + return (filled[0], [arr.offsets_from_codes(codes) for codes in filled[1]]) + + if len(filled[0]) > 0: + points = arr.concat_points(filled[0]) + codes = arr.concat_codes(filled[1]) + else: + points = None + codes = None + + if fill_type_to == FillType.ChunkCombinedCode: + return ([points], [codes]) + elif fill_type_to == FillType.ChunkCombinedOffset: + return ([points], [None if codes is None else arr.offsets_from_codes(codes)]) + elif fill_type_to == FillType.ChunkCombinedCodeOffset: + outer_offsets = None if points is None else arr.offsets_from_lengths(filled[0]) + ret1: cpy.FillReturn_ChunkCombinedCodeOffset = ([points], [codes], [outer_offsets]) + return ret1 + elif fill_type_to == FillType.ChunkCombinedOffsetOffset: + if codes is None: + ret2: cpy.FillReturn_ChunkCombinedOffsetOffset = ([None], [None], [None]) + else: + offsets = arr.offsets_from_codes(codes) + outer_offsets = arr.outer_offsets_from_list_of_codes(filled[1]) + ret2 = ([points], [offsets], [outer_offsets]) + return ret2 + else: + raise ValueError(f"Invalid FillType {fill_type_to}") + + +def _convert_filled_from_OuterOffset( + filled: cpy.FillReturn_OuterOffset, + fill_type_to: FillType, +) -> cpy.FillReturn: + if fill_type_to == FillType.OuterCode: + separate_codes = [arr.codes_from_offsets(offsets) for offsets in filled[1]] + return (filled[0], separate_codes) + elif fill_type_to == FillType.OuterOffset: + return filled + + if len(filled[0]) > 0: + points = arr.concat_points(filled[0]) + offsets = arr.concat_offsets(filled[1]) + else: + points = None + offsets = None + + if fill_type_to == FillType.ChunkCombinedCode: + return ([points], [None if offsets is None else arr.codes_from_offsets(offsets)]) + elif fill_type_to == FillType.ChunkCombinedOffset: + return ([points], [offsets]) + elif fill_type_to == FillType.ChunkCombinedCodeOffset: + if offsets is None: + ret1: cpy.FillReturn_ChunkCombinedCodeOffset = ([None], [None], [None]) + else: + codes = arr.codes_from_offsets(offsets) + outer_offsets = arr.offsets_from_lengths(filled[0]) + ret1 = ([points], [codes], [outer_offsets]) + return ret1 + elif fill_type_to == FillType.ChunkCombinedOffsetOffset: + if points is None: + ret2: cpy.FillReturn_ChunkCombinedOffsetOffset = ([None], [None], [None]) + else: + outer_offsets = arr.outer_offsets_from_list_of_offsets(filled[1]) + ret2 = ([points], [offsets], [outer_offsets]) + return ret2 + else: + raise ValueError(f"Invalid FillType {fill_type_to}") + + +def _convert_filled_from_ChunkCombinedCode( + filled: cpy.FillReturn_ChunkCombinedCode, + fill_type_to: FillType, +) -> cpy.FillReturn: + if fill_type_to == FillType.ChunkCombinedCode: + return filled + elif fill_type_to == FillType.ChunkCombinedOffset: + codes = [None if codes is None else arr.offsets_from_codes(codes) for codes in filled[1]] + return (filled[0], codes) + else: + raise ValueError( + f"Conversion from {FillType.ChunkCombinedCode} to {fill_type_to} not supported") + + +def _convert_filled_from_ChunkCombinedOffset( + filled: cpy.FillReturn_ChunkCombinedOffset, + fill_type_to: FillType, +) -> cpy.FillReturn: + if fill_type_to == FillType.ChunkCombinedCode: + chunk_codes: list[cpy.CodeArray | None] = [] + for points, offsets in zip(*filled): + if points is None: + chunk_codes.append(None) + else: + if TYPE_CHECKING: + assert offsets is not None + chunk_codes.append(arr.codes_from_offsets_and_points(offsets, points)) + return (filled[0], chunk_codes) + elif fill_type_to == FillType.ChunkCombinedOffset: + return filled + else: + raise ValueError( + f"Conversion from {FillType.ChunkCombinedOffset} to {fill_type_to} not supported") + + +def _convert_filled_from_ChunkCombinedCodeOffset( + filled: cpy.FillReturn_ChunkCombinedCodeOffset, + fill_type_to: FillType, +) -> cpy.FillReturn: + if fill_type_to == FillType.OuterCode: + separate_points = [] + separate_codes = [] + for points, codes, outer_offsets in zip(*filled): + if points is not None: + if TYPE_CHECKING: + assert codes is not None + assert outer_offsets is not None + separate_points += arr.split_points_by_offsets(points, outer_offsets) + separate_codes += arr.split_codes_by_offsets(codes, outer_offsets) + return (separate_points, separate_codes) + elif fill_type_to == FillType.OuterOffset: + separate_points = [] + separate_offsets = [] + for points, codes, outer_offsets in zip(*filled): + if points is not None: + if TYPE_CHECKING: + assert codes is not None + assert outer_offsets is not None + separate_points += arr.split_points_by_offsets(points, outer_offsets) + separate_codes = arr.split_codes_by_offsets(codes, outer_offsets) + separate_offsets += [arr.offsets_from_codes(codes) for codes in separate_codes] + return (separate_points, separate_offsets) + elif fill_type_to == FillType.ChunkCombinedCode: + ret1: cpy.FillReturn_ChunkCombinedCode = (filled[0], filled[1]) + return ret1 + elif fill_type_to == FillType.ChunkCombinedOffset: + all_offsets = [None if codes is None else arr.offsets_from_codes(codes) + for codes in filled[1]] + ret2: cpy.FillReturn_ChunkCombinedOffset = (filled[0], all_offsets) + return ret2 + elif fill_type_to == FillType.ChunkCombinedCodeOffset: + return filled + elif fill_type_to == FillType.ChunkCombinedOffsetOffset: + chunk_offsets: list[cpy.OffsetArray | None] = [] + chunk_outer_offsets: list[cpy.OffsetArray | None] = [] + for codes, outer_offsets in zip(*filled[1:]): + if codes is None: + chunk_offsets.append(None) + chunk_outer_offsets.append(None) + else: + if TYPE_CHECKING: + assert outer_offsets is not None + offsets = arr.offsets_from_codes(codes) + outer_offsets = np.array([np.nonzero(offsets == oo)[0][0] for oo in outer_offsets], + dtype=offset_dtype) + chunk_offsets.append(offsets) + chunk_outer_offsets.append(outer_offsets) + ret3: cpy.FillReturn_ChunkCombinedOffsetOffset = ( + filled[0], chunk_offsets, chunk_outer_offsets, + ) + return ret3 + else: + raise ValueError(f"Invalid FillType {fill_type_to}") + + +def _convert_filled_from_ChunkCombinedOffsetOffset( + filled: cpy.FillReturn_ChunkCombinedOffsetOffset, + fill_type_to: FillType, +) -> cpy.FillReturn: + if fill_type_to == FillType.OuterCode: + separate_points = [] + separate_codes = [] + for points, offsets, outer_offsets in zip(*filled): + if points is not None: + if TYPE_CHECKING: + assert offsets is not None + assert outer_offsets is not None + codes = arr.codes_from_offsets_and_points(offsets, points) + outer_offsets = offsets[outer_offsets] + separate_points += arr.split_points_by_offsets(points, outer_offsets) + separate_codes += arr.split_codes_by_offsets(codes, outer_offsets) + return (separate_points, separate_codes) + elif fill_type_to == FillType.OuterOffset: + separate_points = [] + separate_offsets = [] + for points, offsets, outer_offsets in zip(*filled): + if points is not None: + if TYPE_CHECKING: + assert offsets is not None + assert outer_offsets is not None + if len(outer_offsets) > 2: + separate_offsets += [offsets[s:e+1] - offsets[s] for s, e in + pairwise(outer_offsets)] + else: + separate_offsets.append(offsets) + separate_points += arr.split_points_by_offsets(points, offsets[outer_offsets]) + return (separate_points, separate_offsets) + elif fill_type_to == FillType.ChunkCombinedCode: + chunk_codes: list[cpy.CodeArray | None] = [] + for points, offsets, outer_offsets in zip(*filled): + if points is None: + chunk_codes.append(None) + else: + if TYPE_CHECKING: + assert offsets is not None + assert outer_offsets is not None + chunk_codes.append(arr.codes_from_offsets_and_points(offsets, points)) + ret1: cpy.FillReturn_ChunkCombinedCode = (filled[0], chunk_codes) + return ret1 + elif fill_type_to == FillType.ChunkCombinedOffset: + return (filled[0], filled[1]) + elif fill_type_to == FillType.ChunkCombinedCodeOffset: + chunk_codes = [] + chunk_outer_offsets: list[cpy.OffsetArray | None] = [] + for points, offsets, outer_offsets in zip(*filled): + if points is None: + chunk_codes.append(None) + chunk_outer_offsets.append(None) + else: + if TYPE_CHECKING: + assert offsets is not None + assert outer_offsets is not None + chunk_codes.append(arr.codes_from_offsets_and_points(offsets, points)) + chunk_outer_offsets.append(offsets[outer_offsets]) + ret2: cpy.FillReturn_ChunkCombinedCodeOffset = (filled[0], chunk_codes, chunk_outer_offsets) + return ret2 + elif fill_type_to == FillType.ChunkCombinedOffsetOffset: + return filled + else: + raise ValueError(f"Invalid FillType {fill_type_to}") + + +def convert_filled( + filled: cpy.FillReturn, + fill_type_from: FillType | str, + fill_type_to: FillType | str, +) -> cpy.FillReturn: + """Convert filled contours from one :class:`~.FillType` to another. + + Args: + filled (sequence of arrays): Filled contour polygons to convert, such as those returned by + :meth:`.ContourGenerator.filled`. + fill_type_from (FillType or str): :class:`~.FillType` to convert from as enum or + string equivalent. + fill_type_to (FillType or str): :class:`~.FillType` to convert to as enum or string + equivalent. + + Return: + Converted filled contour polygons. + + When converting non-chunked fill types (``FillType.OuterCode`` or ``FillType.OuterOffset``) to + chunked ones, all polygons are placed in the first chunk. When converting in the other + direction, all chunk information is discarded. Converting a fill type that is not aware of the + relationship between outer boundaries and contained holes (``FillType.ChunkCombinedCode`` or + ``FillType.ChunkCombinedOffset``) to one that is will raise a ``ValueError``. + + .. versionadded:: 1.2.0 + """ + fill_type_from = as_fill_type(fill_type_from) + fill_type_to = as_fill_type(fill_type_to) + + check_filled(filled, fill_type_from) + + if fill_type_from == FillType.OuterCode: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_OuterCode, filled) + return _convert_filled_from_OuterCode(filled, fill_type_to) + elif fill_type_from == FillType.OuterOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_OuterOffset, filled) + return _convert_filled_from_OuterOffset(filled, fill_type_to) + elif fill_type_from == FillType.ChunkCombinedCode: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedCode, filled) + return _convert_filled_from_ChunkCombinedCode(filled, fill_type_to) + elif fill_type_from == FillType.ChunkCombinedOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedOffset, filled) + return _convert_filled_from_ChunkCombinedOffset(filled, fill_type_to) + elif fill_type_from == FillType.ChunkCombinedCodeOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedCodeOffset, filled) + return _convert_filled_from_ChunkCombinedCodeOffset(filled, fill_type_to) + elif fill_type_from == FillType.ChunkCombinedOffsetOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedOffsetOffset, filled) + return _convert_filled_from_ChunkCombinedOffsetOffset(filled, fill_type_to) + else: + raise ValueError(f"Invalid FillType {fill_type_from}") + + +def _convert_lines_from_Separate( + lines: cpy.LineReturn_Separate, + line_type_to: LineType, +) -> cpy.LineReturn: + if line_type_to == LineType.Separate: + return lines + elif line_type_to == LineType.SeparateCode: + separate_codes = [arr.codes_from_points(line) for line in lines] + return (lines, separate_codes) + elif line_type_to == LineType.ChunkCombinedCode: + if not lines: + ret1: cpy.LineReturn_ChunkCombinedCode = ([None], [None]) + else: + points = arr.concat_points(lines) + offsets = arr.offsets_from_lengths(lines) + codes = arr.codes_from_offsets_and_points(offsets, points) + ret1 = ([points], [codes]) + return ret1 + elif line_type_to == LineType.ChunkCombinedOffset: + if not lines: + ret2: cpy.LineReturn_ChunkCombinedOffset = ([None], [None]) + else: + ret2 = ([arr.concat_points(lines)], [arr.offsets_from_lengths(lines)]) + return ret2 + elif line_type_to == LineType.ChunkCombinedNan: + if not lines: + ret3: cpy.LineReturn_ChunkCombinedNan = ([None],) + else: + ret3 = ([arr.concat_points_with_nan(lines)],) + return ret3 + else: + raise ValueError(f"Invalid LineType {line_type_to}") + + +def _convert_lines_from_SeparateCode( + lines: cpy.LineReturn_SeparateCode, + line_type_to: LineType, +) -> cpy.LineReturn: + if line_type_to == LineType.Separate: + # Drop codes. + return lines[0] + elif line_type_to == LineType.SeparateCode: + return lines + elif line_type_to == LineType.ChunkCombinedCode: + if not lines[0]: + ret1: cpy.LineReturn_ChunkCombinedCode = ([None], [None]) + else: + ret1 = ([arr.concat_points(lines[0])], [arr.concat_codes(lines[1])]) + return ret1 + elif line_type_to == LineType.ChunkCombinedOffset: + if not lines[0]: + ret2: cpy.LineReturn_ChunkCombinedOffset = ([None], [None]) + else: + ret2 = ([arr.concat_points(lines[0])], [arr.offsets_from_lengths(lines[0])]) + return ret2 + elif line_type_to == LineType.ChunkCombinedNan: + if not lines[0]: + ret3: cpy.LineReturn_ChunkCombinedNan = ([None],) + else: + ret3 = ([arr.concat_points_with_nan(lines[0])],) + return ret3 + else: + raise ValueError(f"Invalid LineType {line_type_to}") + + +def _convert_lines_from_ChunkCombinedCode( + lines: cpy.LineReturn_ChunkCombinedCode, + line_type_to: LineType, +) -> cpy.LineReturn: + if line_type_to in (LineType.Separate, LineType.SeparateCode): + separate_lines = [] + for points, codes in zip(*lines): + if points is not None: + if TYPE_CHECKING: + assert codes is not None + split_at = np.nonzero(codes == MOVETO)[0] + if len(split_at) > 1: + separate_lines += np.split(points, split_at[1:]) + else: + separate_lines.append(points) + if line_type_to == LineType.Separate: + return separate_lines + else: + separate_codes = [arr.codes_from_points(line) for line in separate_lines] + return (separate_lines, separate_codes) + elif line_type_to == LineType.ChunkCombinedCode: + return lines + elif line_type_to == LineType.ChunkCombinedOffset: + chunk_offsets = [None if codes is None else arr.offsets_from_codes(codes) + for codes in lines[1]] + return (lines[0], chunk_offsets) + elif line_type_to == LineType.ChunkCombinedNan: + points_nan: list[cpy.PointArray | None] = [] + for points, codes in zip(*lines): + if points is None: + points_nan.append(None) + else: + if TYPE_CHECKING: + assert codes is not None + offsets = arr.offsets_from_codes(codes) + points_nan.append(arr.insert_nan_at_offsets(points, offsets)) + return (points_nan,) + else: + raise ValueError(f"Invalid LineType {line_type_to}") + + +def _convert_lines_from_ChunkCombinedOffset( + lines: cpy.LineReturn_ChunkCombinedOffset, + line_type_to: LineType, +) -> cpy.LineReturn: + if line_type_to in (LineType.Separate, LineType.SeparateCode): + separate_lines = [] + for points, offsets in zip(*lines): + if points is not None: + if TYPE_CHECKING: + assert offsets is not None + separate_lines += arr.split_points_by_offsets(points, offsets) + if line_type_to == LineType.Separate: + return separate_lines + else: + separate_codes = [arr.codes_from_points(line) for line in separate_lines] + return (separate_lines, separate_codes) + elif line_type_to == LineType.ChunkCombinedCode: + chunk_codes: list[cpy.CodeArray | None] = [] + for points, offsets in zip(*lines): + if points is None: + chunk_codes.append(None) + else: + if TYPE_CHECKING: + assert offsets is not None + chunk_codes.append(arr.codes_from_offsets_and_points(offsets, points)) + return (lines[0], chunk_codes) + elif line_type_to == LineType.ChunkCombinedOffset: + return lines + elif line_type_to == LineType.ChunkCombinedNan: + points_nan: list[cpy.PointArray | None] = [] + for points, offsets in zip(*lines): + if points is None: + points_nan.append(None) + else: + if TYPE_CHECKING: + assert offsets is not None + points_nan.append(arr.insert_nan_at_offsets(points, offsets)) + return (points_nan,) + else: + raise ValueError(f"Invalid LineType {line_type_to}") + + +def _convert_lines_from_ChunkCombinedNan( + lines: cpy.LineReturn_ChunkCombinedNan, + line_type_to: LineType, +) -> cpy.LineReturn: + if line_type_to in (LineType.Separate, LineType.SeparateCode): + separate_lines = [] + for points in lines[0]: + if points is not None: + separate_lines += arr.split_points_at_nan(points) + if line_type_to == LineType.Separate: + return separate_lines + else: + separate_codes = [arr.codes_from_points(points) for points in separate_lines] + return (separate_lines, separate_codes) + elif line_type_to == LineType.ChunkCombinedCode: + chunk_points: list[cpy.PointArray | None] = [] + chunk_codes: list[cpy.CodeArray | None] = [] + for points in lines[0]: + if points is None: + chunk_points.append(None) + chunk_codes.append(None) + else: + points, offsets = arr.remove_nan(points) + chunk_points.append(points) + chunk_codes.append(arr.codes_from_offsets_and_points(offsets, points)) + return (chunk_points, chunk_codes) + elif line_type_to == LineType.ChunkCombinedOffset: + chunk_points = [] + chunk_offsets: list[cpy.OffsetArray | None] = [] + for points in lines[0]: + if points is None: + chunk_points.append(None) + chunk_offsets.append(None) + else: + points, offsets = arr.remove_nan(points) + chunk_points.append(points) + chunk_offsets.append(offsets) + return (chunk_points, chunk_offsets) + elif line_type_to == LineType.ChunkCombinedNan: + return lines + else: + raise ValueError(f"Invalid LineType {line_type_to}") + + +def convert_lines( + lines: cpy.LineReturn, + line_type_from: LineType | str, + line_type_to: LineType | str, +) -> cpy.LineReturn: + """Convert contour lines from one :class:`~.LineType` to another. + + Args: + lines (sequence of arrays): Contour lines to convert, such as those returned by + :meth:`.ContourGenerator.lines`. + line_type_from (LineType or str): :class:`~.LineType` to convert from as enum or + string equivalent. + line_type_to (LineType or str): :class:`~.LineType` to convert to as enum or string + equivalent. + + Return: + Converted contour lines. + + When converting non-chunked line types (``LineType.Separate`` or ``LineType.SeparateCode``) to + chunked ones (``LineType.ChunkCombinedCode``, ``LineType.ChunkCombinedOffset`` or + ``LineType.ChunkCombinedNan``), all lines are placed in the first chunk. When converting in the + other direction, all chunk information is discarded. + + .. versionadded:: 1.2.0 + """ + line_type_from = as_line_type(line_type_from) + line_type_to = as_line_type(line_type_to) + + check_lines(lines, line_type_from) + + if line_type_from == LineType.Separate: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_Separate, lines) + return _convert_lines_from_Separate(lines, line_type_to) + elif line_type_from == LineType.SeparateCode: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_SeparateCode, lines) + return _convert_lines_from_SeparateCode(lines, line_type_to) + elif line_type_from == LineType.ChunkCombinedCode: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_ChunkCombinedCode, lines) + return _convert_lines_from_ChunkCombinedCode(lines, line_type_to) + elif line_type_from == LineType.ChunkCombinedOffset: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_ChunkCombinedOffset, lines) + return _convert_lines_from_ChunkCombinedOffset(lines, line_type_to) + elif line_type_from == LineType.ChunkCombinedNan: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_ChunkCombinedNan, lines) + return _convert_lines_from_ChunkCombinedNan(lines, line_type_to) + else: + raise ValueError(f"Invalid LineType {line_type_from}") + + +def convert_multi_filled( + multi_filled: list[cpy.FillReturn], + fill_type_from: FillType | str, + fill_type_to: FillType | str, +) -> list[cpy.FillReturn]: + """Convert multiple sets of filled contours from one :class:`~.FillType` to another. + + Args: + multi_filled (nested sequence of arrays): Filled contour polygons to convert, such as those + returned by :meth:`.ContourGenerator.multi_filled`. + fill_type_from (FillType or str): :class:`~.FillType` to convert from as enum or + string equivalent. + fill_type_to (FillType or str): :class:`~.FillType` to convert to as enum or string + equivalent. + + Return: + Converted sets filled contour polygons. + + When converting non-chunked fill types (``FillType.OuterCode`` or ``FillType.OuterOffset``) to + chunked ones, all polygons are placed in the first chunk. When converting in the other + direction, all chunk information is discarded. Converting a fill type that is not aware of the + relationship between outer boundaries and contained holes (``FillType.ChunkCombinedCode`` or + ``FillType.ChunkCombinedOffset``) to one that is will raise a ``ValueError``. + + .. versionadded:: 1.3.0 + """ + fill_type_from = as_fill_type(fill_type_from) + fill_type_to = as_fill_type(fill_type_to) + + return [convert_filled(filled, fill_type_from, fill_type_to) for filled in multi_filled] + + +def convert_multi_lines( + multi_lines: list[cpy.LineReturn], + line_type_from: LineType | str, + line_type_to: LineType | str, +) -> list[cpy.LineReturn]: + """Convert multiple sets of contour lines from one :class:`~.LineType` to another. + + Args: + multi_lines (nested sequence of arrays): Contour lines to convert, such as those returned by + :meth:`.ContourGenerator.multi_lines`. + line_type_from (LineType or str): :class:`~.LineType` to convert from as enum or + string equivalent. + line_type_to (LineType or str): :class:`~.LineType` to convert to as enum or string + equivalent. + + Return: + Converted set of contour lines. + + When converting non-chunked line types (``LineType.Separate`` or ``LineType.SeparateCode``) to + chunked ones (``LineType.ChunkCombinedCode``, ``LineType.ChunkCombinedOffset`` or + ``LineType.ChunkCombinedNan``), all lines are placed in the first chunk. When converting in the + other direction, all chunk information is discarded. + + .. versionadded:: 1.3.0 + """ + line_type_from = as_line_type(line_type_from) + line_type_to = as_line_type(line_type_to) + + return [convert_lines(lines, line_type_from, line_type_to) for lines in multi_lines] diff --git a/vllm/lib/python3.10/site-packages/contourpy/dechunk.py b/vllm/lib/python3.10/site-packages/contourpy/dechunk.py new file mode 100644 index 0000000000000000000000000000000000000000..f571b4b5ffbb4801cd687b065314b51a93a1997d --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/dechunk.py @@ -0,0 +1,207 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, cast + +from contourpy._contourpy import FillType, LineType +from contourpy.array import ( + concat_codes_or_none, + concat_offsets_or_none, + concat_points_or_none, + concat_points_or_none_with_nan, +) +from contourpy.enum_util import as_fill_type, as_line_type +from contourpy.typecheck import check_filled, check_lines + +if TYPE_CHECKING: + import contourpy._contourpy as cpy + + +def dechunk_filled(filled: cpy.FillReturn, fill_type: FillType | str) -> cpy.FillReturn: + """Return the specified filled contours with chunked data moved into the first chunk. + + Filled contours that are not chunked (``FillType.OuterCode`` and ``FillType.OuterOffset``) and + those that are but only contain a single chunk are returned unmodified. Individual polygons are + unchanged, they are not geometrically combined. + + Args: + filled (sequence of arrays): Filled contour data, such as returned by + :meth:`.ContourGenerator.filled`. + fill_type (FillType or str): Type of :meth:`~.ContourGenerator.filled` as enum or string + equivalent. + + Return: + Filled contours in a single chunk. + + .. versionadded:: 1.2.0 + """ + fill_type = as_fill_type(fill_type) + + if fill_type in (FillType.OuterCode, FillType.OuterOffset): + # No-op if fill_type is not chunked. + return filled + + check_filled(filled, fill_type) + if len(filled[0]) < 2: + # No-op if just one chunk. + return filled + + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_Chunk, filled) + points = concat_points_or_none(filled[0]) + + if fill_type == FillType.ChunkCombinedCode: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedCode, filled) + if points is None: + ret1: cpy.FillReturn_ChunkCombinedCode = ([None], [None]) + else: + ret1 = ([points], [concat_codes_or_none(filled[1])]) + return ret1 + elif fill_type == FillType.ChunkCombinedOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedOffset, filled) + if points is None: + ret2: cpy.FillReturn_ChunkCombinedOffset = ([None], [None]) + else: + ret2 = ([points], [concat_offsets_or_none(filled[1])]) + return ret2 + elif fill_type == FillType.ChunkCombinedCodeOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedCodeOffset, filled) + if points is None: + ret3: cpy.FillReturn_ChunkCombinedCodeOffset = ([None], [None], [None]) + else: + outer_offsets = concat_offsets_or_none(filled[2]) + ret3 = ([points], [concat_codes_or_none(filled[1])], [outer_offsets]) + return ret3 + elif fill_type == FillType.ChunkCombinedOffsetOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedOffsetOffset, filled) + if points is None: + ret4: cpy.FillReturn_ChunkCombinedOffsetOffset = ([None], [None], [None]) + else: + outer_offsets = concat_offsets_or_none(filled[2]) + ret4 = ([points], [concat_offsets_or_none(filled[1])], [outer_offsets]) + return ret4 + else: + raise ValueError(f"Invalid FillType {fill_type}") + + +def dechunk_lines(lines: cpy.LineReturn, line_type: LineType | str) -> cpy.LineReturn: + """Return the specified contour lines with chunked data moved into the first chunk. + + Contour lines that are not chunked (``LineType.Separate`` and ``LineType.SeparateCode``) and + those that are but only contain a single chunk are returned unmodified. Individual lines are + unchanged, they are not geometrically combined. + + Args: + lines (sequence of arrays): Contour line data, such as returned by + :meth:`.ContourGenerator.lines`. + line_type (LineType or str): Type of :meth:`~.ContourGenerator.lines` as enum or string + equivalent. + + Return: + Contour lines in a single chunk. + + .. versionadded:: 1.2.0 + """ + line_type = as_line_type(line_type) + + if line_type in (LineType.Separate, LineType.SeparateCode): + # No-op if line_type is not chunked. + return lines + + check_lines(lines, line_type) + if len(lines[0]) < 2: + # No-op if just one chunk. + return lines + + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_Chunk, lines) + + if line_type == LineType.ChunkCombinedCode: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_ChunkCombinedCode, lines) + points = concat_points_or_none(lines[0]) + if points is None: + ret1: cpy.LineReturn_ChunkCombinedCode = ([None], [None]) + else: + ret1 = ([points], [concat_codes_or_none(lines[1])]) + return ret1 + elif line_type == LineType.ChunkCombinedOffset: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_ChunkCombinedOffset, lines) + points = concat_points_or_none(lines[0]) + if points is None: + ret2: cpy.LineReturn_ChunkCombinedOffset = ([None], [None]) + else: + ret2 = ([points], [concat_offsets_or_none(lines[1])]) + return ret2 + elif line_type == LineType.ChunkCombinedNan: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_ChunkCombinedNan, lines) + points = concat_points_or_none_with_nan(lines[0]) + ret3: cpy.LineReturn_ChunkCombinedNan = ([points],) + return ret3 + else: + raise ValueError(f"Invalid LineType {line_type}") + + +def dechunk_multi_filled( + multi_filled: list[cpy.FillReturn], + fill_type: FillType | str, +) -> list[cpy.FillReturn]: + """Return multiple sets of filled contours with chunked data moved into the first chunks. + + Filled contours that are not chunked (``FillType.OuterCode`` and ``FillType.OuterOffset``) and + those that are but only contain a single chunk are returned unmodified. Individual polygons are + unchanged, they are not geometrically combined. + + Args: + multi_filled (nested sequence of arrays): Filled contour data, such as returned by + :meth:`.ContourGenerator.multi_filled`. + fill_type (FillType or str): Type of :meth:`~.ContourGenerator.filled` as enum or string + equivalent. + + Return: + Multiple sets of filled contours in a single chunk. + + .. versionadded:: 1.3.0 + """ + fill_type = as_fill_type(fill_type) + + if fill_type in (FillType.OuterCode, FillType.OuterOffset): + # No-op if fill_type is not chunked. + return multi_filled + + return [dechunk_filled(filled, fill_type) for filled in multi_filled] + + +def dechunk_multi_lines( + multi_lines: list[cpy.LineReturn], + line_type: LineType | str, +) -> list[cpy.LineReturn]: + """Return multiple sets of contour lines with all chunked data moved into the first chunks. + + Contour lines that are not chunked (``LineType.Separate`` and ``LineType.SeparateCode``) and + those that are but only contain a single chunk are returned unmodified. Individual lines are + unchanged, they are not geometrically combined. + + Args: + multi_lines (nested sequence of arrays): Contour line data, such as returned by + :meth:`.ContourGenerator.multi_lines`. + line_type (LineType or str): Type of :meth:`~.ContourGenerator.lines` as enum or string + equivalent. + + Return: + Multiple sets of contour lines in a single chunk. + + .. versionadded:: 1.3.0 + """ + line_type = as_line_type(line_type) + + if line_type in (LineType.Separate, LineType.SeparateCode): + # No-op if line_type is not chunked. + return multi_lines + + return [dechunk_lines(lines, line_type) for lines in multi_lines] diff --git a/vllm/lib/python3.10/site-packages/contourpy/enum_util.py b/vllm/lib/python3.10/site-packages/contourpy/enum_util.py new file mode 100644 index 0000000000000000000000000000000000000000..14229abebf7e342a2834ffec2a0ad427a727fa5c --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/enum_util.py @@ -0,0 +1,57 @@ +from __future__ import annotations + +from contourpy._contourpy import FillType, LineType, ZInterp + + +def as_fill_type(fill_type: FillType | str) -> FillType: + """Coerce a FillType or string value to a FillType. + + Args: + fill_type (FillType or str): Value to convert. + + Return: + FillType: Converted value. + """ + if isinstance(fill_type, str): + try: + return FillType.__members__[fill_type] + except KeyError as e: + raise ValueError(f"'{fill_type}' is not a valid FillType") from e + else: + return fill_type + + +def as_line_type(line_type: LineType | str) -> LineType: + """Coerce a LineType or string value to a LineType. + + Args: + line_type (LineType or str): Value to convert. + + Return: + LineType: Converted value. + """ + if isinstance(line_type, str): + try: + return LineType.__members__[line_type] + except KeyError as e: + raise ValueError(f"'{line_type}' is not a valid LineType") from e + else: + return line_type + + +def as_z_interp(z_interp: ZInterp | str) -> ZInterp: + """Coerce a ZInterp or string value to a ZInterp. + + Args: + z_interp (ZInterp or str): Value to convert. + + Return: + ZInterp: Converted value. + """ + if isinstance(z_interp, str): + try: + return ZInterp.__members__[z_interp] + except KeyError as e: + raise ValueError(f"'{z_interp}' is not a valid ZInterp") from e + else: + return z_interp diff --git a/vllm/lib/python3.10/site-packages/contourpy/py.typed b/vllm/lib/python3.10/site-packages/contourpy/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/vllm/lib/python3.10/site-packages/contourpy/typecheck.py b/vllm/lib/python3.10/site-packages/contourpy/typecheck.py new file mode 100644 index 0000000000000000000000000000000000000000..23fbd54856a96f6b6b60b8557c76936f615a9cdc --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/typecheck.py @@ -0,0 +1,203 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, cast + +import numpy as np + +from contourpy import FillType, LineType +from contourpy.enum_util import as_fill_type, as_line_type +from contourpy.types import MOVETO, code_dtype, offset_dtype, point_dtype + +if TYPE_CHECKING: + import contourpy._contourpy as cpy + + +# Minimalist array-checking functions that check dtype, ndims and shape only. +# They do not walk the arrays to check the contents for performance reasons. +def check_code_array(codes: Any) -> None: + if not isinstance(codes, np.ndarray): + raise TypeError(f"Expected numpy array not {type(codes)}") + if codes.dtype != code_dtype: + raise ValueError(f"Expected numpy array of dtype {code_dtype} not {codes.dtype}") + if not (codes.ndim == 1 and len(codes) > 1): + raise ValueError(f"Expected numpy array of shape (?,) not {codes.shape}") + if codes[0] != MOVETO: + raise ValueError(f"First element of code array must be {MOVETO}, not {codes[0]}") + + +def check_offset_array(offsets: Any) -> None: + if not isinstance(offsets, np.ndarray): + raise TypeError(f"Expected numpy array not {type(offsets)}") + if offsets.dtype != offset_dtype: + raise ValueError(f"Expected numpy array of dtype {offset_dtype} not {offsets.dtype}") + if not (offsets.ndim == 1 and len(offsets) > 1): + raise ValueError(f"Expected numpy array of shape (?,) not {offsets.shape}") + if offsets[0] != 0: + raise ValueError(f"First element of offset array must be 0, not {offsets[0]}") + + +def check_point_array(points: Any) -> None: + if not isinstance(points, np.ndarray): + raise TypeError(f"Expected numpy array not {type(points)}") + if points.dtype != point_dtype: + raise ValueError(f"Expected numpy array of dtype {point_dtype} not {points.dtype}") + if not (points.ndim == 2 and points.shape[1] ==2 and points.shape[0] > 1): + raise ValueError(f"Expected numpy array of shape (?, 2) not {points.shape}") + + +def _check_tuple_of_lists_with_same_length( + maybe_tuple: Any, + tuple_length: int, + allow_empty_lists: bool = True, +) -> None: + if not isinstance(maybe_tuple, tuple): + raise TypeError(f"Expected tuple not {type(maybe_tuple)}") + if len(maybe_tuple) != tuple_length: + raise ValueError(f"Expected tuple of length {tuple_length} not {len(maybe_tuple)}") + for maybe_list in maybe_tuple: + if not isinstance(maybe_list, list): + msg = f"Expected tuple to contain {tuple_length} lists but found a {type(maybe_list)}" + raise TypeError(msg) + lengths = [len(item) for item in maybe_tuple] + if len(set(lengths)) != 1: + msg = f"Expected {tuple_length} lists with same length but lengths are {lengths}" + raise ValueError(msg) + if not allow_empty_lists and lengths[0] == 0: + raise ValueError(f"Expected {tuple_length} non-empty lists") + + +def check_filled(filled: cpy.FillReturn, fill_type: FillType | str) -> None: + fill_type = as_fill_type(fill_type) + + if fill_type == FillType.OuterCode: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_OuterCode, filled) + _check_tuple_of_lists_with_same_length(filled, 2) + for i, (points, codes) in enumerate(zip(*filled)): + check_point_array(points) + check_code_array(codes) + if len(points) != len(codes): + raise ValueError(f"Points and codes have different lengths in polygon {i}") + elif fill_type == FillType.OuterOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_OuterOffset, filled) + _check_tuple_of_lists_with_same_length(filled, 2) + for i, (points, offsets) in enumerate(zip(*filled)): + check_point_array(points) + check_offset_array(offsets) + if offsets[-1] != len(points): + raise ValueError(f"Inconsistent points and offsets in polygon {i}") + elif fill_type == FillType.ChunkCombinedCode: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedCode, filled) + _check_tuple_of_lists_with_same_length(filled, 2, allow_empty_lists=False) + for chunk, (points_or_none, codes_or_none) in enumerate(zip(*filled)): + if points_or_none is not None and codes_or_none is not None: + check_point_array(points_or_none) + check_code_array(codes_or_none) + if len(points_or_none) != len(codes_or_none): + raise ValueError(f"Points and codes have different lengths in chunk {chunk}") + elif not (points_or_none is None and codes_or_none is None): + raise ValueError(f"Inconsistent Nones in chunk {chunk}") + elif fill_type == FillType.ChunkCombinedOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedOffset, filled) + _check_tuple_of_lists_with_same_length(filled, 2, allow_empty_lists=False) + for chunk, (points_or_none, offsets_or_none) in enumerate(zip(*filled)): + if points_or_none is not None and offsets_or_none is not None: + check_point_array(points_or_none) + check_offset_array(offsets_or_none) + if offsets_or_none[-1] != len(points_or_none): + raise ValueError(f"Inconsistent points and offsets in chunk {chunk}") + elif not (points_or_none is None and offsets_or_none is None): + raise ValueError(f"Inconsistent Nones in chunk {chunk}") + elif fill_type == FillType.ChunkCombinedCodeOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedCodeOffset, filled) + _check_tuple_of_lists_with_same_length(filled, 3, allow_empty_lists=False) + for i, (points_or_none, codes_or_none, outer_offsets_or_none) in enumerate(zip(*filled)): + if (points_or_none is not None and codes_or_none is not None and + outer_offsets_or_none is not None): + check_point_array(points_or_none) + check_code_array(codes_or_none) + check_offset_array(outer_offsets_or_none) + if len(codes_or_none) != len(points_or_none): + raise ValueError(f"Points and codes have different lengths in chunk {i}") + if outer_offsets_or_none[-1] != len(codes_or_none): + raise ValueError(f"Inconsistent codes and outer_offsets in chunk {i}") + elif not (points_or_none is None and codes_or_none is None and + outer_offsets_or_none is None): + raise ValueError(f"Inconsistent Nones in chunk {i}") + elif fill_type == FillType.ChunkCombinedOffsetOffset: + if TYPE_CHECKING: + filled = cast(cpy.FillReturn_ChunkCombinedOffsetOffset, filled) + _check_tuple_of_lists_with_same_length(filled, 3, allow_empty_lists=False) + for i, (points_or_none, offsets_or_none, outer_offsets_or_none) in enumerate(zip(*filled)): + if (points_or_none is not None and offsets_or_none is not None and + outer_offsets_or_none is not None): + check_point_array(points_or_none) + check_offset_array(offsets_or_none) + check_offset_array(outer_offsets_or_none) + if offsets_or_none[-1] != len(points_or_none): + raise ValueError(f"Inconsistent points and offsets in chunk {i}") + if outer_offsets_or_none[-1] != len(offsets_or_none) - 1: + raise ValueError(f"Inconsistent offsets and outer_offsets in chunk {i}") + elif not (points_or_none is None and offsets_or_none is None and + outer_offsets_or_none is None): + raise ValueError(f"Inconsistent Nones in chunk {i}") + else: + raise ValueError(f"Invalid FillType {fill_type}") + + +def check_lines(lines: cpy.LineReturn, line_type: LineType | str) -> None: + line_type = as_line_type(line_type) + + if line_type == LineType.Separate: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_Separate, lines) + if not isinstance(lines, list): + raise TypeError(f"Expected list not {type(lines)}") + for points in lines: + check_point_array(points) + elif line_type == LineType.SeparateCode: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_SeparateCode, lines) + _check_tuple_of_lists_with_same_length(lines, 2) + for i, (points, codes) in enumerate(zip(*lines)): + check_point_array(points) + check_code_array(codes) + if len(points) != len(codes): + raise ValueError(f"Points and codes have different lengths in line {i}") + elif line_type == LineType.ChunkCombinedCode: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_ChunkCombinedCode, lines) + _check_tuple_of_lists_with_same_length(lines, 2, allow_empty_lists=False) + for chunk, (points_or_none, codes_or_none) in enumerate(zip(*lines)): + if points_or_none is not None and codes_or_none is not None: + check_point_array(points_or_none) + check_code_array(codes_or_none) + if len(points_or_none) != len(codes_or_none): + raise ValueError(f"Points and codes have different lengths in chunk {chunk}") + elif not (points_or_none is None and codes_or_none is None): + raise ValueError(f"Inconsistent Nones in chunk {chunk}") + elif line_type == LineType.ChunkCombinedOffset: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_ChunkCombinedOffset, lines) + _check_tuple_of_lists_with_same_length(lines, 2, allow_empty_lists=False) + for chunk, (points_or_none, offsets_or_none) in enumerate(zip(*lines)): + if points_or_none is not None and offsets_or_none is not None: + check_point_array(points_or_none) + check_offset_array(offsets_or_none) + if offsets_or_none[-1] != len(points_or_none): + raise ValueError(f"Inconsistent points and offsets in chunk {chunk}") + elif not (points_or_none is None and offsets_or_none is None): + raise ValueError(f"Inconsistent Nones in chunk {chunk}") + elif line_type == LineType.ChunkCombinedNan: + if TYPE_CHECKING: + lines = cast(cpy.LineReturn_ChunkCombinedNan, lines) + _check_tuple_of_lists_with_same_length(lines, 1, allow_empty_lists=False) + for _chunk, points_or_none in enumerate(lines[0]): + if points_or_none is not None: + check_point_array(points_or_none) + else: + raise ValueError(f"Invalid LineType {line_type}") diff --git a/vllm/lib/python3.10/site-packages/contourpy/types.py b/vllm/lib/python3.10/site-packages/contourpy/types.py new file mode 100644 index 0000000000000000000000000000000000000000..e704b98eac0736d83586c66803db6b79cdfc5967 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/types.py @@ -0,0 +1,13 @@ +from __future__ import annotations + +import numpy as np + +# dtypes of arrays returned by ContourPy. +point_dtype = np.float64 +code_dtype = np.uint8 +offset_dtype = np.uint32 + +# Kind codes used in Matplotlib Paths. +MOVETO = 1 +LINETO = 2 +CLOSEPOLY = 79 diff --git a/vllm/lib/python3.10/site-packages/contourpy/util/__init__.py b/vllm/lib/python3.10/site-packages/contourpy/util/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fe33fcef1e18d2a4b92287e434cf6b1257e4274f --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/util/__init__.py @@ -0,0 +1,5 @@ +from __future__ import annotations + +from contourpy.util._build_config import build_config + +__all__ = ["build_config"] diff --git a/vllm/lib/python3.10/site-packages/contourpy/util/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/util/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..96f2ced54aa0b183dc40e8baaa8f2be97d23da27 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/util/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/util/__pycache__/mpl_util.cpython-310.pyc b/vllm/lib/python3.10/site-packages/contourpy/util/__pycache__/mpl_util.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e333adc0fa8e2322838f32a0673a7c97a5093ee Binary files /dev/null and b/vllm/lib/python3.10/site-packages/contourpy/util/__pycache__/mpl_util.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/contourpy/util/_build_config.py b/vllm/lib/python3.10/site-packages/contourpy/util/_build_config.py new file mode 100644 index 0000000000000000000000000000000000000000..141f960eae59fcd4c646d6b293d5d78c128241ea --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/util/_build_config.py @@ -0,0 +1,60 @@ +# _build_config.py.in is converted into _build_config.py during the meson build process. + +from __future__ import annotations + + +def build_config() -> dict[str, str]: + """ + Return a dictionary containing build configuration settings. + + All dictionary keys and values are strings, for example ``False`` is + returned as ``"False"``. + + .. versionadded:: 1.1.0 + """ + return dict( + # Python settings + python_version="3.10", + python_install_dir=r"/usr/local/lib/python3.10/site-packages/", + python_path=r"/tmp/build-env-wg5819kv/bin/python", + + # Package versions + contourpy_version="1.3.1", + meson_version="1.6.0", + mesonpy_version="0.17.1", + pybind11_version="2.13.6", + + # Misc meson settings + meson_backend="ninja", + build_dir=r"/project/.mesonpy-6u_kjjys/lib/contourpy/util", + source_dir=r"/project/lib/contourpy/util", + cross_build="False", + + # Build options + build_options=r"-Dbuildtype=release -Db_ndebug=if-release -Db_vscrt=md -Dvsenv=True --native-file=/project/.mesonpy-6u_kjjys/meson-python-native-file.ini", + buildtype="release", + cpp_std="c++17", + debug="False", + optimization="3", + vsenv="True", + b_ndebug="if-release", + b_vscrt="from_buildtype", + + # C++ compiler + compiler_name="gcc", + compiler_version="10.2.1", + linker_id="ld.bfd", + compile_command="c++", + + # Host machine + host_cpu="x86_64", + host_cpu_family="x86_64", + host_cpu_endian="little", + host_cpu_system="linux", + + # Build machine, same as host machine if not a cross_build + build_cpu="x86_64", + build_cpu_family="x86_64", + build_cpu_endian="little", + build_cpu_system="linux", + ) diff --git a/vllm/lib/python3.10/site-packages/contourpy/util/bokeh_renderer.py b/vllm/lib/python3.10/site-packages/contourpy/util/bokeh_renderer.py new file mode 100644 index 0000000000000000000000000000000000000000..e20dc9cfe585aa3d82fe9094a3966dad26e9f401 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/util/bokeh_renderer.py @@ -0,0 +1,336 @@ +from __future__ import annotations + +import io +from typing import TYPE_CHECKING, Any + +from bokeh.io import export_png, export_svg, show +from bokeh.io.export import get_screenshot_as_png +from bokeh.layouts import gridplot +from bokeh.models.annotations.labels import Label +from bokeh.palettes import Category10 +from bokeh.plotting import figure +import numpy as np + +from contourpy.enum_util import as_fill_type, as_line_type +from contourpy.util.bokeh_util import filled_to_bokeh, lines_to_bokeh +from contourpy.util.renderer import Renderer + +if TYPE_CHECKING: + from bokeh.models import GridPlot + from bokeh.palettes import Palette + from numpy.typing import ArrayLike + from selenium.webdriver.remote.webdriver import WebDriver + + from contourpy import FillType, LineType + from contourpy._contourpy import FillReturn, LineReturn + + +class BokehRenderer(Renderer): + """Utility renderer using Bokeh to render a grid of plots over the same (x, y) range. + + Args: + nrows (int, optional): Number of rows of plots, default ``1``. + ncols (int, optional): Number of columns of plots, default ``1``. + figsize (tuple(float, float), optional): Figure size in inches (assuming 100 dpi), default + ``(9, 9)``. + show_frame (bool, optional): Whether to show frame and axes ticks, default ``True``. + want_svg (bool, optional): Whether output is required in SVG format or not, default + ``False``. + + Warning: + :class:`~.BokehRenderer`, unlike :class:`~.MplRenderer`, needs to be told in advance if + output to SVG format will be required later, otherwise it will assume PNG output. + """ + _figures: list[figure] + _layout: GridPlot + _palette: Palette + _want_svg: bool + + def __init__( + self, + nrows: int = 1, + ncols: int = 1, + figsize: tuple[float, float] = (9, 9), + show_frame: bool = True, + want_svg: bool = False, + ) -> None: + self._want_svg = want_svg + self._palette = Category10[10] + + total_size = 100*np.asarray(figsize, dtype=int) # Assuming 100 dpi. + + nfigures = nrows*ncols + self._figures = [] + backend = "svg" if self._want_svg else "canvas" + for _ in range(nfigures): + fig = figure(output_backend=backend) + fig.xgrid.visible = False + fig.ygrid.visible = False + self._figures.append(fig) + if not show_frame: + fig.outline_line_color = None # type: ignore[assignment] + fig.axis.visible = False + + self._layout = gridplot( + self._figures, ncols=ncols, toolbar_location=None, # type: ignore[arg-type] + width=total_size[0] // ncols, height=total_size[1] // nrows) + + def _convert_color(self, color: str) -> str: + if isinstance(color, str) and color[0] == "C": + index = int(color[1:]) + color = self._palette[index] + return color + + def _get_figure(self, ax: figure | int) -> figure: + if isinstance(ax, int): + ax = self._figures[ax] + return ax + + def filled( + self, + filled: FillReturn, + fill_type: FillType | str, + ax: figure | int = 0, + color: str = "C0", + alpha: float = 0.7, + ) -> None: + """Plot filled contours on a single plot. + + Args: + filled (sequence of arrays): Filled contour data as returned by + :meth:`~.ContourGenerator.filled`. + fill_type (FillType or str): Type of :meth:`~.ContourGenerator.filled` data as returned + by :attr:`~.ContourGenerator.fill_type`, or a string equivalent. + ax (int or Bokeh Figure, optional): Which plot to use, default ``0``. + color (str, optional): Color to plot with. May be a string color or the letter ``"C"`` + followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the + ``Category10`` palette. Default ``"C0"``. + alpha (float, optional): Opacity to plot with, default ``0.7``. + """ + fill_type = as_fill_type(fill_type) + fig = self._get_figure(ax) + color = self._convert_color(color) + xs, ys = filled_to_bokeh(filled, fill_type) + if len(xs) > 0: + fig.multi_polygons(xs=[xs], ys=[ys], color=color, fill_alpha=alpha, line_width=0) + + def grid( + self, + x: ArrayLike, + y: ArrayLike, + ax: figure | int = 0, + color: str = "black", + alpha: float = 0.1, + point_color: str | None = None, + quad_as_tri_alpha: float = 0, + ) -> None: + """Plot quad grid lines on a single plot. + + Args: + x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points. + y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points. + ax (int or Bokeh Figure, optional): Which plot to use, default ``0``. + color (str, optional): Color to plot grid lines, default ``"black"``. + alpha (float, optional): Opacity to plot lines with, default ``0.1``. + point_color (str, optional): Color to plot grid points or ``None`` if grid points + should not be plotted, default ``None``. + quad_as_tri_alpha (float, optional): Opacity to plot ``quad_as_tri`` grid, default + ``0``. + + Colors may be a string color or the letter ``"C"`` followed by an integer in the range + ``"C0"`` to ``"C9"`` to use a color from the ``Category10`` palette. + + Warning: + ``quad_as_tri_alpha > 0`` plots all quads as though they are unmasked. + """ + fig = self._get_figure(ax) + x, y = self._grid_as_2d(x, y) + xs = list(x) + list(x.T) + ys = list(y) + list(y.T) + kwargs = {"line_color": color, "alpha": alpha} + fig.multi_line(xs, ys, **kwargs) + if quad_as_tri_alpha > 0: + # Assumes no quad mask. + xmid = (0.25*(x[:-1, :-1] + x[1:, :-1] + x[:-1, 1:] + x[1:, 1:])).ravel() + ymid = (0.25*(y[:-1, :-1] + y[1:, :-1] + y[:-1, 1:] + y[1:, 1:])).ravel() + fig.multi_line( + list(np.stack((x[:-1, :-1].ravel(), xmid, x[1:, 1:].ravel()), axis=1)), + list(np.stack((y[:-1, :-1].ravel(), ymid, y[1:, 1:].ravel()), axis=1)), + **kwargs) + fig.multi_line( + list(np.stack((x[:-1, 1:].ravel(), xmid, x[1:, :-1].ravel()), axis=1)), + list(np.stack((y[:-1, 1:].ravel(), ymid, y[1:, :-1].ravel()), axis=1)), + **kwargs) + if point_color is not None: + fig.scatter( + x=x.ravel(), y=y.ravel(), fill_color=color, line_color=None, alpha=alpha, + marker="circle", size=8) + + def lines( + self, + lines: LineReturn, + line_type: LineType | str, + ax: figure | int = 0, + color: str = "C0", + alpha: float = 1.0, + linewidth: float = 1, + ) -> None: + """Plot contour lines on a single plot. + + Args: + lines (sequence of arrays): Contour line data as returned by + :meth:`~.ContourGenerator.lines`. + line_type (LineType or str): Type of :meth:`~.ContourGenerator.lines` data as returned + by :attr:`~.ContourGenerator.line_type`, or a string equivalent. + ax (int or Bokeh Figure, optional): Which plot to use, default ``0``. + color (str, optional): Color to plot lines. May be a string color or the letter ``"C"`` + followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the + ``Category10`` palette. Default ``"C0"``. + alpha (float, optional): Opacity to plot lines with, default ``1.0``. + linewidth (float, optional): Width of lines, default ``1``. + + Note: + Assumes all lines are open line strips not closed line loops. + """ + line_type = as_line_type(line_type) + fig = self._get_figure(ax) + color = self._convert_color(color) + xs, ys = lines_to_bokeh(lines, line_type) + if xs is not None: + fig.line(xs, ys, line_color=color, line_alpha=alpha, line_width=linewidth) + + def mask( + self, + x: ArrayLike, + y: ArrayLike, + z: ArrayLike | np.ma.MaskedArray[Any, Any], + ax: figure | int = 0, + color: str = "black", + ) -> None: + """Plot masked out grid points as circles on a single plot. + + Args: + x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points. + y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points. + z (masked array of shape (ny, nx): z-values. + ax (int or Bokeh Figure, optional): Which plot to use, default ``0``. + color (str, optional): Circle color, default ``"black"``. + """ + mask = np.ma.getmask(z) # type: ignore[no-untyped-call] + if mask is np.ma.nomask: + return + fig = self._get_figure(ax) + color = self._convert_color(color) + x, y = self._grid_as_2d(x, y) + fig.scatter(x[mask], y[mask], fill_color=color, marker="circle", size=10) + + def save( + self, + filename: str, + transparent: bool = False, + *, + webdriver: WebDriver | None = None, + ) -> None: + """Save plots to SVG or PNG file. + + Args: + filename (str): Filename to save to. + transparent (bool, optional): Whether background should be transparent, default + ``False``. + webdriver (WebDriver, optional): Selenium WebDriver instance to use to create the image. + + .. versionadded:: 1.1.1 + + Warning: + To output to SVG file, ``want_svg=True`` must have been passed to the constructor. + """ + if transparent: + for fig in self._figures: + fig.background_fill_color = None # type: ignore[assignment] + fig.border_fill_color = None # type: ignore[assignment] + + if self._want_svg: + export_svg(self._layout, filename=filename, webdriver=webdriver) + else: + export_png(self._layout, filename=filename, webdriver=webdriver) + + def save_to_buffer(self, *, webdriver: WebDriver | None = None) -> io.BytesIO: + """Save plots to an ``io.BytesIO`` buffer. + + Args: + webdriver (WebDriver, optional): Selenium WebDriver instance to use to create the image. + + .. versionadded:: 1.1.1 + + Return: + BytesIO: PNG image buffer. + """ + image = get_screenshot_as_png(self._layout, driver=webdriver) + buffer = io.BytesIO() + image.save(buffer, "png") + return buffer + + def show(self) -> None: + """Show plots in web browser, in usual Bokeh manner. + """ + show(self._layout) + + def title(self, title: str, ax: figure | int = 0, color: str | None = None) -> None: + """Set the title of a single plot. + + Args: + title (str): Title text. + ax (int or Bokeh Figure, optional): Which plot to set the title of, default ``0``. + color (str, optional): Color to set title. May be a string color or the letter ``"C"`` + followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the + ``Category10`` palette. Default ``None`` which is ``black``. + """ + fig = self._get_figure(ax) + fig.title = title # type: ignore[assignment] + fig.title.align = "center" # type: ignore[attr-defined] + if color is not None: + fig.title.text_color = self._convert_color(color) # type: ignore[attr-defined] + + def z_values( + self, + x: ArrayLike, + y: ArrayLike, + z: ArrayLike, + ax: figure | int = 0, + color: str = "green", + fmt: str = ".1f", + quad_as_tri: bool = False, + ) -> None: + """Show ``z`` values on a single plot. + + Args: + x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points. + y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points. + z (array-like of shape (ny, nx): z-values. + ax (int or Bokeh Figure, optional): Which plot to use, default ``0``. + color (str, optional): Color of added text. May be a string color or the letter ``"C"`` + followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the + ``Category10`` palette. Default ``"green"``. + fmt (str, optional): Format to display z-values, default ``".1f"``. + quad_as_tri (bool, optional): Whether to show z-values at the ``quad_as_tri`` centres + of quads. + + Warning: + ``quad_as_tri=True`` shows z-values for all quads, even if masked. + """ + fig = self._get_figure(ax) + color = self._convert_color(color) + x, y = self._grid_as_2d(x, y) + z = np.asarray(z) + ny, nx = z.shape + kwargs = {"text_color": color, "text_align": "center", "text_baseline": "middle"} + for j in range(ny): + for i in range(nx): + fig.add_layout(Label(x=x[j, i], y=y[j, i], text=f"{z[j, i]:{fmt}}", **kwargs)) + if quad_as_tri: + for j in range(ny-1): + for i in range(nx-1): + xx = np.mean(x[j:j+2, i:i+2]) + yy = np.mean(y[j:j+2, i:i+2]) + zz = np.mean(z[j:j+2, i:i+2]) + fig.add_layout(Label(x=xx, y=yy, text=f"{zz:{fmt}}", **kwargs)) diff --git a/vllm/lib/python3.10/site-packages/contourpy/util/bokeh_util.py b/vllm/lib/python3.10/site-packages/contourpy/util/bokeh_util.py new file mode 100644 index 0000000000000000000000000000000000000000..e75eb844536b26dfe90de08bb65328e5d2e5ba1c --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/util/bokeh_util.py @@ -0,0 +1,74 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, cast + +from contourpy import FillType, LineType +from contourpy.array import offsets_from_codes +from contourpy.convert import convert_lines +from contourpy.dechunk import dechunk_lines + +if TYPE_CHECKING: + from contourpy._contourpy import ( + CoordinateArray, + FillReturn, + LineReturn, + LineReturn_ChunkCombinedNan, + ) + + +def filled_to_bokeh( + filled: FillReturn, + fill_type: FillType, +) -> tuple[list[list[CoordinateArray]], list[list[CoordinateArray]]]: + xs: list[list[CoordinateArray]] = [] + ys: list[list[CoordinateArray]] = [] + if fill_type in (FillType.OuterOffset, FillType.ChunkCombinedOffset, + FillType.OuterCode, FillType.ChunkCombinedCode): + have_codes = fill_type in (FillType.OuterCode, FillType.ChunkCombinedCode) + + for points, offsets in zip(*filled): + if points is None: + continue + if have_codes: + offsets = offsets_from_codes(offsets) + xs.append([]) # New outer with zero or more holes. + ys.append([]) + for i in range(len(offsets)-1): + xys = points[offsets[i]:offsets[i+1]] + xs[-1].append(xys[:, 0]) + ys[-1].append(xys[:, 1]) + elif fill_type in (FillType.ChunkCombinedCodeOffset, FillType.ChunkCombinedOffsetOffset): + for points, codes_or_offsets, outer_offsets in zip(*filled): + if points is None: + continue + for j in range(len(outer_offsets)-1): + if fill_type == FillType.ChunkCombinedCodeOffset: + codes = codes_or_offsets[outer_offsets[j]:outer_offsets[j+1]] + offsets = offsets_from_codes(codes) + outer_offsets[j] + else: + offsets = codes_or_offsets[outer_offsets[j]:outer_offsets[j+1]+1] + xs.append([]) # New outer with zero or more holes. + ys.append([]) + for k in range(len(offsets)-1): + xys = points[offsets[k]:offsets[k+1]] + xs[-1].append(xys[:, 0]) + ys[-1].append(xys[:, 1]) + else: + raise RuntimeError(f"Conversion of FillType {fill_type} to Bokeh is not implemented") + + return xs, ys + + +def lines_to_bokeh( + lines: LineReturn, + line_type: LineType, +) -> tuple[CoordinateArray | None, CoordinateArray | None]: + lines = convert_lines(lines, line_type, LineType.ChunkCombinedNan) + lines = dechunk_lines(lines, LineType.ChunkCombinedNan) + if TYPE_CHECKING: + lines = cast(LineReturn_ChunkCombinedNan, lines) + points = lines[0][0] + if points is None: + return None, None + else: + return points[:, 0], points[:, 1] diff --git a/vllm/lib/python3.10/site-packages/contourpy/util/data.py b/vllm/lib/python3.10/site-packages/contourpy/util/data.py new file mode 100644 index 0000000000000000000000000000000000000000..5fa75486958c8277430f149daf872e859de8e000 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/util/data.py @@ -0,0 +1,78 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any + +import numpy as np + +if TYPE_CHECKING: + from contourpy._contourpy import CoordinateArray + + +def simple( + shape: tuple[int, int], want_mask: bool = False, +) -> tuple[CoordinateArray, CoordinateArray, CoordinateArray | np.ma.MaskedArray[Any, Any]]: + """Return simple test data consisting of the sum of two gaussians. + + Args: + shape (tuple(int, int)): 2D shape of data to return. + want_mask (bool, optional): Whether test data should be masked or not, default ``False``. + + Return: + Tuple of 3 arrays: ``x``, ``y``, ``z`` test data, ``z`` will be masked if + ``want_mask=True``. + """ + ny, nx = shape + x = np.arange(nx, dtype=np.float64) + y = np.arange(ny, dtype=np.float64) + x, y = np.meshgrid(x, y) + + xscale = nx - 1.0 + yscale = ny - 1.0 + + # z is sum of 2D gaussians. + amp = np.asarray([1.0, -1.0, 0.8, -0.9, 0.7]) + mid = np.asarray([[0.4, 0.2], [0.3, 0.8], [0.9, 0.75], [0.7, 0.3], [0.05, 0.7]]) + width = np.asarray([0.4, 0.2, 0.2, 0.2, 0.1]) + + z = np.zeros_like(x) + for i in range(len(amp)): + z += amp[i]*np.exp(-((x/xscale - mid[i, 0])**2 + (y/yscale - mid[i, 1])**2) / width[i]**2) + + if want_mask: + mask = np.logical_or( + ((x/xscale - 1.0)**2 / 0.2 + (y/yscale - 0.0)**2 / 0.1) < 1.0, + ((x/xscale - 0.2)**2 / 0.02 + (y/yscale - 0.45)**2 / 0.08) < 1.0, + ) + z = np.ma.array(z, mask=mask) # type: ignore[no-untyped-call] + + return x, y, z + + +def random( + shape: tuple[int, int], seed: int = 2187, mask_fraction: float = 0.0, +) -> tuple[CoordinateArray, CoordinateArray, CoordinateArray | np.ma.MaskedArray[Any, Any]]: + """Return random test data in the range 0 to 1. + + Args: + shape (tuple(int, int)): 2D shape of data to return. + seed (int, optional): Seed for random number generator, default 2187. + mask_fraction (float, optional): Fraction of elements to mask, default 0. + + Return: + Tuple of 3 arrays: ``x``, ``y``, ``z`` test data, ``z`` will be masked if + ``mask_fraction`` is greater than zero. + """ + ny, nx = shape + x = np.arange(nx, dtype=np.float64) + y = np.arange(ny, dtype=np.float64) + x, y = np.meshgrid(x, y) + + rng = np.random.default_rng(seed) + z = rng.uniform(size=shape) + + if mask_fraction > 0.0: + mask_fraction = min(mask_fraction, 0.99) + mask = rng.uniform(size=shape) < mask_fraction + z = np.ma.array(z, mask=mask) # type: ignore[no-untyped-call] + + return x, y, z diff --git a/vllm/lib/python3.10/site-packages/contourpy/util/mpl_renderer.py b/vllm/lib/python3.10/site-packages/contourpy/util/mpl_renderer.py new file mode 100644 index 0000000000000000000000000000000000000000..401c9056ffe47b2ed1ed52f3355690fdb2b78910 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/util/mpl_renderer.py @@ -0,0 +1,535 @@ +from __future__ import annotations + +import io +from itertools import pairwise +from typing import TYPE_CHECKING, Any, cast + +import matplotlib.collections as mcollections +import matplotlib.pyplot as plt +import numpy as np + +from contourpy import FillType, LineType +from contourpy.convert import convert_filled, convert_lines +from contourpy.enum_util import as_fill_type, as_line_type +from contourpy.util.mpl_util import filled_to_mpl_paths, lines_to_mpl_paths +from contourpy.util.renderer import Renderer + +if TYPE_CHECKING: + from collections.abc import Sequence + + from matplotlib.axes import Axes + from matplotlib.figure import Figure + from numpy.typing import ArrayLike + + import contourpy._contourpy as cpy + + +class MplRenderer(Renderer): + """Utility renderer using Matplotlib to render a grid of plots over the same (x, y) range. + + Args: + nrows (int, optional): Number of rows of plots, default ``1``. + ncols (int, optional): Number of columns of plots, default ``1``. + figsize (tuple(float, float), optional): Figure size in inches, default ``(9, 9)``. + show_frame (bool, optional): Whether to show frame and axes ticks, default ``True``. + backend (str, optional): Matplotlib backend to use or ``None`` for default backend. + Default ``None``. + gridspec_kw (dict, optional): Gridspec keyword arguments to pass to ``plt.subplots``, + default None. + """ + _axes: Sequence[Axes] + _fig: Figure + _want_tight: bool + + def __init__( + self, + nrows: int = 1, + ncols: int = 1, + figsize: tuple[float, float] = (9, 9), + show_frame: bool = True, + backend: str | None = None, + gridspec_kw: dict[str, Any] | None = None, + ) -> None: + if backend is not None: + import matplotlib as mpl + mpl.use(backend) + + kwargs: dict[str, Any] = {"figsize": figsize, "squeeze": False, + "sharex": True, "sharey": True} + if gridspec_kw is not None: + kwargs["gridspec_kw"] = gridspec_kw + else: + kwargs["subplot_kw"] = {"aspect": "equal"} + + self._fig, axes = plt.subplots(nrows, ncols, **kwargs) + self._axes = axes.flatten() + if not show_frame: + for ax in self._axes: + ax.axis("off") + + self._want_tight = True + + def __del__(self) -> None: + if hasattr(self, "_fig"): + plt.close(self._fig) + + def _autoscale(self) -> None: + # Using axes._need_autoscale attribute if need to autoscale before rendering after adding + # lines/filled. Only want to autoscale once per axes regardless of how many lines/filled + # added. + for ax in self._axes: + if getattr(ax, "_need_autoscale", False): + ax.autoscale_view(tight=True) + ax._need_autoscale = False # type: ignore[attr-defined] + if self._want_tight and len(self._axes) > 1: + self._fig.tight_layout() + + def _get_ax(self, ax: Axes | int) -> Axes: + if isinstance(ax, int): + ax = self._axes[ax] + return ax + + def filled( + self, + filled: cpy.FillReturn, + fill_type: FillType | str, + ax: Axes | int = 0, + color: str = "C0", + alpha: float = 0.7, + ) -> None: + """Plot filled contours on a single Axes. + + Args: + filled (sequence of arrays): Filled contour data as returned by + :meth:`~.ContourGenerator.filled`. + fill_type (FillType or str): Type of :meth:`~.ContourGenerator.filled` data as returned + by :attr:`~.ContourGenerator.fill_type`, or string equivalent + ax (int or Maplotlib Axes, optional): Which axes to plot on, default ``0``. + color (str, optional): Color to plot with. May be a string color or the letter ``"C"`` + followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the + ``tab10`` colormap. Default ``"C0"``. + alpha (float, optional): Opacity to plot with, default ``0.7``. + """ + fill_type = as_fill_type(fill_type) + ax = self._get_ax(ax) + paths = filled_to_mpl_paths(filled, fill_type) + collection = mcollections.PathCollection( + paths, facecolors=color, edgecolors="none", lw=0, alpha=alpha) + ax.add_collection(collection) + ax._need_autoscale = True # type: ignore[attr-defined] + + def grid( + self, + x: ArrayLike, + y: ArrayLike, + ax: Axes | int = 0, + color: str = "black", + alpha: float = 0.1, + point_color: str | None = None, + quad_as_tri_alpha: float = 0, + ) -> None: + """Plot quad grid lines on a single Axes. + + Args: + x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points. + y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points. + ax (int or Matplotlib Axes, optional): Which Axes to plot on, default ``0``. + color (str, optional): Color to plot grid lines, default ``"black"``. + alpha (float, optional): Opacity to plot lines with, default ``0.1``. + point_color (str, optional): Color to plot grid points or ``None`` if grid points + should not be plotted, default ``None``. + quad_as_tri_alpha (float, optional): Opacity to plot ``quad_as_tri`` grid, default 0. + + Colors may be a string color or the letter ``"C"`` followed by an integer in the range + ``"C0"`` to ``"C9"`` to use a color from the ``tab10`` colormap. + + Warning: + ``quad_as_tri_alpha > 0`` plots all quads as though they are unmasked. + """ + ax = self._get_ax(ax) + x, y = self._grid_as_2d(x, y) + kwargs: dict[str, Any] = {"color": color, "alpha": alpha} + ax.plot(x, y, x.T, y.T, **kwargs) + if quad_as_tri_alpha > 0: + # Assumes no quad mask. + xmid = 0.25*(x[:-1, :-1] + x[1:, :-1] + x[:-1, 1:] + x[1:, 1:]) + ymid = 0.25*(y[:-1, :-1] + y[1:, :-1] + y[:-1, 1:] + y[1:, 1:]) + kwargs["alpha"] = quad_as_tri_alpha + ax.plot( + np.stack((x[:-1, :-1], xmid, x[1:, 1:])).reshape((3, -1)), + np.stack((y[:-1, :-1], ymid, y[1:, 1:])).reshape((3, -1)), + np.stack((x[1:, :-1], xmid, x[:-1, 1:])).reshape((3, -1)), + np.stack((y[1:, :-1], ymid, y[:-1, 1:])).reshape((3, -1)), + **kwargs) + if point_color is not None: + ax.plot(x, y, color=point_color, alpha=alpha, marker="o", lw=0) + ax._need_autoscale = True # type: ignore[attr-defined] + + def lines( + self, + lines: cpy.LineReturn, + line_type: LineType | str, + ax: Axes | int = 0, + color: str = "C0", + alpha: float = 1.0, + linewidth: float = 1, + ) -> None: + """Plot contour lines on a single Axes. + + Args: + lines (sequence of arrays): Contour line data as returned by + :meth:`~.ContourGenerator.lines`. + line_type (LineType or str): Type of :meth:`~.ContourGenerator.lines` data as returned + by :attr:`~.ContourGenerator.line_type`, or string equivalent. + ax (int or Matplotlib Axes, optional): Which Axes to plot on, default ``0``. + color (str, optional): Color to plot lines. May be a string color or the letter ``"C"`` + followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the + ``tab10`` colormap. Default ``"C0"``. + alpha (float, optional): Opacity to plot lines with, default ``1.0``. + linewidth (float, optional): Width of lines, default ``1``. + """ + line_type = as_line_type(line_type) + ax = self._get_ax(ax) + paths = lines_to_mpl_paths(lines, line_type) + collection = mcollections.PathCollection( + paths, facecolors="none", edgecolors=color, lw=linewidth, alpha=alpha) + ax.add_collection(collection) + ax._need_autoscale = True # type: ignore[attr-defined] + + def mask( + self, + x: ArrayLike, + y: ArrayLike, + z: ArrayLike | np.ma.MaskedArray[Any, Any], + ax: Axes | int = 0, + color: str = "black", + ) -> None: + """Plot masked out grid points as circles on a single Axes. + + Args: + x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points. + y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points. + z (masked array of shape (ny, nx): z-values. + ax (int or Matplotlib Axes, optional): Which Axes to plot on, default ``0``. + color (str, optional): Circle color, default ``"black"``. + """ + mask = np.ma.getmask(z) # type: ignore[no-untyped-call] + if mask is np.ma.nomask: + return + ax = self._get_ax(ax) + x, y = self._grid_as_2d(x, y) + ax.plot(x[mask], y[mask], "o", c=color) + + def save(self, filename: str, transparent: bool = False) -> None: + """Save plots to SVG or PNG file. + + Args: + filename (str): Filename to save to. + transparent (bool, optional): Whether background should be transparent, default + ``False``. + """ + self._autoscale() + self._fig.savefig(filename, transparent=transparent) + + def save_to_buffer(self) -> io.BytesIO: + """Save plots to an ``io.BytesIO`` buffer. + + Return: + BytesIO: PNG image buffer. + """ + self._autoscale() + buf = io.BytesIO() + self._fig.savefig(buf, format="png") + buf.seek(0) + return buf + + def show(self) -> None: + """Show plots in an interactive window, in the usual Matplotlib manner. + """ + self._autoscale() + plt.show() + + def title(self, title: str, ax: Axes | int = 0, color: str | None = None) -> None: + """Set the title of a single Axes. + + Args: + title (str): Title text. + ax (int or Matplotlib Axes, optional): Which Axes to set the title of, default ``0``. + color (str, optional): Color to set title. May be a string color or the letter ``"C"`` + followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the + ``tab10`` colormap. Default is ``None`` which uses Matplotlib's default title color + that depends on the stylesheet in use. + """ + if color: + self._get_ax(ax).set_title(title, color=color) + else: + self._get_ax(ax).set_title(title) + + def z_values( + self, + x: ArrayLike, + y: ArrayLike, + z: ArrayLike, + ax: Axes | int = 0, + color: str = "green", + fmt: str = ".1f", + quad_as_tri: bool = False, + ) -> None: + """Show ``z`` values on a single Axes. + + Args: + x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points. + y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points. + z (array-like of shape (ny, nx): z-values. + ax (int or Matplotlib Axes, optional): Which Axes to plot on, default ``0``. + color (str, optional): Color of added text. May be a string color or the letter ``"C"`` + followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the + ``tab10`` colormap. Default ``"green"``. + fmt (str, optional): Format to display z-values, default ``".1f"``. + quad_as_tri (bool, optional): Whether to show z-values at the ``quad_as_tri`` centers + of quads. + + Warning: + ``quad_as_tri=True`` shows z-values for all quads, even if masked. + """ + ax = self._get_ax(ax) + x, y = self._grid_as_2d(x, y) + z = np.asarray(z) + ny, nx = z.shape + for j in range(ny): + for i in range(nx): + ax.text(x[j, i], y[j, i], f"{z[j, i]:{fmt}}", ha="center", va="center", + color=color, clip_on=True) + if quad_as_tri: + for j in range(ny-1): + for i in range(nx-1): + xx = np.mean(x[j:j+2, i:i+2]) + yy = np.mean(y[j:j+2, i:i+2]) + zz = np.mean(z[j:j+2, i:i+2]) + ax.text(xx, yy, f"{zz:{fmt}}", ha="center", va="center", color=color, + clip_on=True) + + +class MplTestRenderer(MplRenderer): + """Test renderer implemented using Matplotlib. + + No whitespace around plots and no spines/ticks displayed. + Uses Agg backend, so can only save to file/buffer, cannot call ``show()``. + """ + def __init__( + self, + nrows: int = 1, + ncols: int = 1, + figsize: tuple[float, float] = (9, 9), + ) -> None: + gridspec = { + "left": 0.01, + "right": 0.99, + "top": 0.99, + "bottom": 0.01, + "wspace": 0.01, + "hspace": 0.01, + } + super().__init__( + nrows, ncols, figsize, show_frame=True, backend="Agg", gridspec_kw=gridspec, + ) + + for ax in self._axes: + ax.set_xmargin(0.0) + ax.set_ymargin(0.0) + ax.set_xticks([]) + ax.set_yticks([]) + + self._want_tight = False + + +class MplDebugRenderer(MplRenderer): + """Debug renderer implemented using Matplotlib. + + Extends ``MplRenderer`` to add extra information to help in debugging such as markers, arrows, + text, etc. + """ + def __init__( + self, + nrows: int = 1, + ncols: int = 1, + figsize: tuple[float, float] = (9, 9), + show_frame: bool = True, + ) -> None: + super().__init__(nrows, ncols, figsize, show_frame) + + def _arrow( + self, + ax: Axes, + line_start: cpy.CoordinateArray, + line_end: cpy.CoordinateArray, + color: str, + alpha: float, + arrow_size: float, + ) -> None: + mid = 0.5*(line_start + line_end) + along = line_end - line_start + along /= np.sqrt(np.dot(along, along)) # Unit vector. + right = np.asarray((along[1], -along[0])) + arrow = np.stack(( + mid - (along*0.5 - right)*arrow_size, + mid + along*0.5*arrow_size, + mid - (along*0.5 + right)*arrow_size, + )) + ax.plot(arrow[:, 0], arrow[:, 1], "-", c=color, alpha=alpha) + + def filled( + self, + filled: cpy.FillReturn, + fill_type: FillType | str, + ax: Axes | int = 0, + color: str = "C1", + alpha: float = 0.7, + line_color: str = "C0", + line_alpha: float = 0.7, + point_color: str = "C0", + start_point_color: str = "red", + arrow_size: float = 0.1, + ) -> None: + fill_type = as_fill_type(fill_type) + super().filled(filled, fill_type, ax, color, alpha) + + if line_color is None and point_color is None: + return + + ax = self._get_ax(ax) + filled = convert_filled(filled, fill_type, FillType.ChunkCombinedOffset) + + # Lines. + if line_color is not None: + for points, offsets in zip(*filled): + if points is None: + continue + for start, end in pairwise(offsets): + xys = points[start:end] + ax.plot(xys[:, 0], xys[:, 1], c=line_color, alpha=line_alpha) + + if arrow_size > 0.0: + n = len(xys) + for i in range(n-1): + self._arrow(ax, xys[i], xys[i+1], line_color, line_alpha, arrow_size) + + # Points. + if point_color is not None: + for points, offsets in zip(*filled): + if points is None: + continue + mask = np.ones(offsets[-1], dtype=bool) + mask[offsets[1:]-1] = False # Exclude end points. + if start_point_color is not None: + start_indices = offsets[:-1] + mask[start_indices] = False # Exclude start points. + ax.plot( + points[:, 0][mask], points[:, 1][mask], "o", c=point_color, alpha=line_alpha) + + if start_point_color is not None: + ax.plot(points[:, 0][start_indices], points[:, 1][start_indices], "o", + c=start_point_color, alpha=line_alpha) + + def lines( + self, + lines: cpy.LineReturn, + line_type: LineType | str, + ax: Axes | int = 0, + color: str = "C0", + alpha: float = 1.0, + linewidth: float = 1, + point_color: str = "C0", + start_point_color: str = "red", + arrow_size: float = 0.1, + ) -> None: + line_type = as_line_type(line_type) + super().lines(lines, line_type, ax, color, alpha, linewidth) + + if arrow_size == 0.0 and point_color is None: + return + + ax = self._get_ax(ax) + separate_lines = convert_lines(lines, line_type, LineType.Separate) + if TYPE_CHECKING: + separate_lines = cast(cpy.LineReturn_Separate, separate_lines) + + if arrow_size > 0.0: + for line in separate_lines: + for i in range(len(line)-1): + self._arrow(ax, line[i], line[i+1], color, alpha, arrow_size) + + if point_color is not None: + for line in separate_lines: + start_index = 0 + end_index = len(line) + if start_point_color is not None: + ax.plot(line[0, 0], line[0, 1], "o", c=start_point_color, alpha=alpha) + start_index = 1 + if line[0][0] == line[-1][0] and line[0][1] == line[-1][1]: + end_index -= 1 + ax.plot(line[start_index:end_index, 0], line[start_index:end_index, 1], "o", + c=color, alpha=alpha) + + def point_numbers( + self, + x: ArrayLike, + y: ArrayLike, + z: ArrayLike, + ax: Axes | int = 0, + color: str = "red", + ) -> None: + ax = self._get_ax(ax) + x, y = self._grid_as_2d(x, y) + z = np.asarray(z) + ny, nx = z.shape + for j in range(ny): + for i in range(nx): + quad = i + j*nx + ax.text(x[j, i], y[j, i], str(quad), ha="right", va="top", color=color, + clip_on=True) + + def quad_numbers( + self, + x: ArrayLike, + y: ArrayLike, + z: ArrayLike, + ax: Axes | int = 0, + color: str = "blue", + ) -> None: + ax = self._get_ax(ax) + x, y = self._grid_as_2d(x, y) + z = np.asarray(z) + ny, nx = z.shape + for j in range(1, ny): + for i in range(1, nx): + quad = i + j*nx + xmid = x[j-1:j+1, i-1:i+1].mean() + ymid = y[j-1:j+1, i-1:i+1].mean() + ax.text(xmid, ymid, str(quad), ha="center", va="center", color=color, clip_on=True) + + def z_levels( + self, + x: ArrayLike, + y: ArrayLike, + z: ArrayLike, + lower_level: float, + upper_level: float | None = None, + ax: Axes | int = 0, + color: str = "green", + ) -> None: + ax = self._get_ax(ax) + x, y = self._grid_as_2d(x, y) + z = np.asarray(z) + ny, nx = z.shape + for j in range(ny): + for i in range(nx): + zz = z[j, i] + if upper_level is not None and zz > upper_level: + z_level = 2 + elif zz > lower_level: + z_level = 1 + else: + z_level = 0 + ax.text(x[j, i], y[j, i], str(z_level), ha="left", va="bottom", color=color, + clip_on=True) diff --git a/vllm/lib/python3.10/site-packages/contourpy/util/mpl_util.py b/vllm/lib/python3.10/site-packages/contourpy/util/mpl_util.py new file mode 100644 index 0000000000000000000000000000000000000000..d8587798c499a9ab898ee6cb54738be7e41bf7cf --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/util/mpl_util.py @@ -0,0 +1,77 @@ +from __future__ import annotations + +from itertools import pairwise +from typing import TYPE_CHECKING, cast + +import matplotlib.path as mpath +import numpy as np + +from contourpy import FillType, LineType +from contourpy.array import codes_from_offsets + +if TYPE_CHECKING: + from contourpy._contourpy import FillReturn, LineReturn, LineReturn_Separate + + +def filled_to_mpl_paths(filled: FillReturn, fill_type: FillType) -> list[mpath.Path]: + if fill_type in (FillType.OuterCode, FillType.ChunkCombinedCode): + paths = [mpath.Path(points, codes) for points, codes in zip(*filled) if points is not None] + elif fill_type in (FillType.OuterOffset, FillType.ChunkCombinedOffset): + paths = [mpath.Path(points, codes_from_offsets(offsets)) + for points, offsets in zip(*filled) if points is not None] + elif fill_type == FillType.ChunkCombinedCodeOffset: + paths = [] + for points, codes, outer_offsets in zip(*filled): + if points is None: + continue + points = np.split(points, outer_offsets[1:-1]) + codes = np.split(codes, outer_offsets[1:-1]) + paths += [mpath.Path(p, c) for p, c in zip(points, codes)] + elif fill_type == FillType.ChunkCombinedOffsetOffset: + paths = [] + for points, offsets, outer_offsets in zip(*filled): + if points is None: + continue + for i in range(len(outer_offsets)-1): + offs = offsets[outer_offsets[i]:outer_offsets[i+1]+1] + pts = points[offs[0]:offs[-1]] + paths += [mpath.Path(pts, codes_from_offsets(offs - offs[0]))] + else: + raise RuntimeError(f"Conversion of FillType {fill_type} to MPL Paths is not implemented") + return paths + + +def lines_to_mpl_paths(lines: LineReturn, line_type: LineType) -> list[mpath.Path]: + if line_type == LineType.Separate: + if TYPE_CHECKING: + lines = cast(LineReturn_Separate, lines) + paths = [] + for line in lines: + # Drawing as Paths so that they can be closed correctly. + closed = line[0, 0] == line[-1, 0] and line[0, 1] == line[-1, 1] + paths.append(mpath.Path(line, closed=closed)) + elif line_type in (LineType.SeparateCode, LineType.ChunkCombinedCode): + paths = [mpath.Path(points, codes) for points, codes in zip(*lines) if points is not None] + elif line_type == LineType.ChunkCombinedOffset: + paths = [] + for points, offsets in zip(*lines): + if points is None: + continue + for i in range(len(offsets)-1): + line = points[offsets[i]:offsets[i+1]] + closed = line[0, 0] == line[-1, 0] and line[0, 1] == line[-1, 1] + paths.append(mpath.Path(line, closed=closed)) + elif line_type == LineType.ChunkCombinedNan: + paths = [] + for points in lines[0]: + if points is None: + continue + nan_offsets = np.nonzero(np.isnan(points[:, 0]))[0] + nan_offsets = np.concatenate([[-1], nan_offsets, [len(points)]]) + for s, e in pairwise(nan_offsets): + line = points[s+1:e] + closed = line[0, 0] == line[-1, 0] and line[0, 1] == line[-1, 1] + paths.append(mpath.Path(line, closed=closed)) + else: + raise RuntimeError(f"Conversion of LineType {line_type} to MPL Paths is not implemented") + return paths diff --git a/vllm/lib/python3.10/site-packages/contourpy/util/renderer.py b/vllm/lib/python3.10/site-packages/contourpy/util/renderer.py new file mode 100644 index 0000000000000000000000000000000000000000..716569f776c4df9197a36f40e9f0a5e176292114 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/contourpy/util/renderer.py @@ -0,0 +1,166 @@ +from __future__ import annotations + +from abc import ABC, abstractmethod +from typing import TYPE_CHECKING, Any + +import numpy as np + +if TYPE_CHECKING: + import io + + from numpy.typing import ArrayLike + + from contourpy._contourpy import CoordinateArray, FillReturn, FillType, LineReturn, LineType + + +class Renderer(ABC): + """Abstract base class for renderers.""" + + def _grid_as_2d(self, x: ArrayLike, y: ArrayLike) -> tuple[CoordinateArray, CoordinateArray]: + x = np.asarray(x) + y = np.asarray(y) + if x.ndim == 1: + x, y = np.meshgrid(x, y) + return x, y + + @abstractmethod + def filled( + self, + filled: FillReturn, + fill_type: FillType | str, + ax: Any = 0, + color: str = "C0", + alpha: float = 0.7, + ) -> None: + pass + + @abstractmethod + def grid( + self, + x: ArrayLike, + y: ArrayLike, + ax: Any = 0, + color: str = "black", + alpha: float = 0.1, + point_color: str | None = None, + quad_as_tri_alpha: float = 0, + ) -> None: + pass + + @abstractmethod + def lines( + self, + lines: LineReturn, + line_type: LineType | str, + ax: Any = 0, + color: str = "C0", + alpha: float = 1.0, + linewidth: float = 1, + ) -> None: + pass + + @abstractmethod + def mask( + self, + x: ArrayLike, + y: ArrayLike, + z: ArrayLike | np.ma.MaskedArray[Any, Any], + ax: Any = 0, + color: str = "black", + ) -> None: + pass + + def multi_filled( + self, + multi_filled: list[FillReturn], + fill_type: FillType | str, + ax: Any = 0, + color: str | None = None, + **kwargs: Any, + ) -> None: + """Plot multiple sets of filled contours on a single axes. + + Args: + multi_filled (list of filled contour arrays): Multiple filled contour sets as returned + by :meth:`.ContourGenerator.multi_filled`. + fill_type (FillType or str): Type of filled data as returned by + :attr:`~.ContourGenerator.fill_type`, or string equivalent. + ax (int or Renderer-specific axes or figure object, optional): Which axes to plot on, + default ``0``. + color (str or None, optional): If a string color then this same color is used for all + filled contours. If ``None``, the default, then the filled contour sets use colors + from the ``tab10`` colormap in order, wrapping around to the beginning if more than + 10 sets of filled contours are rendered. + kwargs: All other keyword argument are passed on to + :meth:`.Renderer.filled` unchanged. + + .. versionadded:: 1.3.0 + """ + if color is not None: + kwargs["color"] = color + for i, filled in enumerate(multi_filled): + if color is None: + kwargs["color"] = f"C{i % 10}" + self.filled(filled, fill_type, ax, **kwargs) + + def multi_lines( + self, + multi_lines: list[LineReturn], + line_type: LineType | str, + ax: Any = 0, + color: str | None = None, + **kwargs: Any, + ) -> None: + """Plot multiple sets of contour lines on a single axes. + + Args: + multi_lines (list of contour line arrays): Multiple contour line sets as returned by + :meth:`.ContourGenerator.multi_lines`. + line_type (LineType or str): Type of line data as returned by + :attr:`~.ContourGenerator.line_type`, or string equivalent. + ax (int or Renderer-specific axes or figure object, optional): Which axes to plot on, + default ``0``. + color (str or None, optional): If a string color then this same color is used for all + lines. If ``None``, the default, then the line sets use colors from the ``tab10`` + colormap in order, wrapping around to the beginning if more than 10 sets of lines + are rendered. + kwargs: All other keyword argument are passed on to + :meth:`Renderer.lines` unchanged. + + .. versionadded:: 1.3.0 + """ + if color is not None: + kwargs["color"] = color + for i, lines in enumerate(multi_lines): + if color is None: + kwargs["color"] = f"C{i % 10}" + self.lines(lines, line_type, ax, **kwargs) + + @abstractmethod + def save(self, filename: str, transparent: bool = False) -> None: + pass + + @abstractmethod + def save_to_buffer(self) -> io.BytesIO: + pass + + @abstractmethod + def show(self) -> None: + pass + + @abstractmethod + def title(self, title: str, ax: Any = 0, color: str | None = None) -> None: + pass + + @abstractmethod + def z_values( + self, + x: ArrayLike, + y: ArrayLike, + z: ArrayLike, + ax: Any = 0, + color: str = "green", + fmt: str = ".1f", + quad_as_tri: bool = False, + ) -> None: + pass diff --git a/vllm/lib/python3.10/site-packages/freetype/__init__.py b/vllm/lib/python3.10/site-packages/freetype/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b68126423524c51f9559b870b4aca7ecf48076ee --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/__init__.py @@ -0,0 +1,2413 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +''' +FreeType high-level python API + +This the bindings for the high-level API of FreeType (that must be installed +somewhere on your system). + +Note: C Library will be searched using the ctypes.util.find_library. However, + this search might fail. In such a case (or for other reasons), you may + have to specify an explicit path below. +''' +import io +import sys +from ctypes import * +import ctypes.util +import struct + +from freetype.raw import * + +# Hack to get unicode class in python3 +PY3 = sys.version_info[0] == 3 +if PY3: unicode = str + + +def unmake_tag(i): + # roughly opposite of FT_MAKE_TAG, converts 32-bit int to Python string + # could do with .to_bytes if limited to Python 3.2 or higher... + b = struct.pack('>I', i) + return b.decode('ascii', errors='replace') + +_handle = None + + +FT_Library_filename = filename + +class _FT_Library_Wrapper(FT_Library): + '''Subclass of FT_Library to help with calling FT_Done_FreeType''' + # for some reason this doesn't get carried over and ctypes complains + _type_ = FT_Library._type_ + + # Store ref to FT_Done_FreeType otherwise it will be deleted before needed. + _ft_done_freetype = FT_Done_FreeType + + def __del__(self): + # call FT_Done_FreeType + # This does not work properly (seg fault on sime system (OSX)) + # self._ft_done_freetype(self) + pass + + +def _init_freetype(): + global _handle + + _handle = _FT_Library_Wrapper() + error = FT_Init_FreeType( byref(_handle) ) + + if error: raise FT_Exception(error) + + try: + set_lcd_filter( FT_LCD_FILTER_DEFAULT ) + except: + pass + +# ----------------------------------------------------------------------------- +# High-level API of FreeType 2 +# ----------------------------------------------------------------------------- + + +def get_handle(): + ''' + Get unique FT_Library handle + ''' + + if not _handle: + _init_freetype() + + return _handle + +def version(): + ''' + Return the version of the FreeType library being used as a tuple of + ( major version number, minor version number, patch version number ) + ''' + amajor = FT_Int() + aminor = FT_Int() + apatch = FT_Int() + + library = get_handle() + FT_Library_Version(library, byref(amajor), byref(aminor), byref(apatch)) + return (amajor.value, aminor.value, apatch.value) + + +# ----------------------------------------------------------------------------- +# Stand alone functions +# ----------------------------------------------------------------------------- +def set_lcd_filter(filt): + ''' + This function is used to apply color filtering to LCD decimated bitmaps, + like the ones used when calling FT_Render_Glyph with FT_RENDER_MODE_LCD or + FT_RENDER_MODE_LCD_V. + + **Note** + + This feature is always disabled by default. Clients must make an explicit + call to this function with a 'filter' value other than FT_LCD_FILTER_NONE + in order to enable it. + + Due to PATENTS covering subpixel rendering, this function doesn't do + anything except returning 'FT_Err_Unimplemented_Feature' if the + configuration macro FT_CONFIG_OPTION_SUBPIXEL_RENDERING is not defined in + your build of the library, which should correspond to all default builds of + FreeType. + + The filter affects glyph bitmaps rendered through FT_Render_Glyph, + FT_Outline_Get_Bitmap, FT_Load_Glyph, and FT_Load_Char. + + It does not affect the output of FT_Outline_Render and + FT_Outline_Get_Bitmap. + + If this feature is activated, the dimensions of LCD glyph bitmaps are + either larger or taller than the dimensions of the corresponding outline + with regards to the pixel grid. For example, for FT_RENDER_MODE_LCD, the + filter adds up to 3 pixels to the left, and up to 3 pixels to the right. + + The bitmap offset values are adjusted correctly, so clients shouldn't need + to modify their layout and glyph positioning code when enabling the filter. + ''' + library = get_handle() + error = FT_Library_SetLcdFilter(library, filt) + if error: raise FT_Exception(error) + + + +def set_lcd_filter_weights(a,b,c,d,e): + ''' + Use this function to override the filter weights selected by + FT_Library_SetLcdFilter. By default, FreeType uses the quintuple (0x00, + 0x55, 0x56, 0x55, 0x00) for FT_LCD_FILTER_LIGHT, and (0x10, 0x40, 0x70, + 0x40, 0x10) for FT_LCD_FILTER_DEFAULT and FT_LCD_FILTER_LEGACY. + + **Note** + + Only available if version > 2.4.0 + ''' + if version()>=(2,4,0): + library = get_handle() + weights = FT_Char(5)(a,b,c,d,e) + error = FT_Library_SetLcdFilterWeights(library, weights) + if error: raise FT_Exception(error) + else: + raise RuntimeError( + 'set_lcd_filter_weights require freetype > 2.4.0') + + +def _encode_filename(filename): + encoded = filename.encode(sys.getfilesystemencoding()) + if "?" not in filename and b"?" in encoded: + # A bug, decoding mbcs always ignore exception, still isn't fixed in Python 2, + # view http://bugs.python.org/issue850997 for detail + raise UnicodeError() + return encoded + + + +# ----------------------------------------------------------------------------- +# Direct wrapper (simple renaming) +# ----------------------------------------------------------------------------- +Vector = FT_Vector +Matrix = FT_Matrix + + +# ----------------------------------------------------------------------------- +# Handling for FT_Done_MM_Var, which was added in FreeType 2.9. Prior to that, +# we need to import libc and use libc free on the memory allocated for the +# FT_MM_Var data structure. See Face.get_variation_info(). +# ----------------------------------------------------------------------------- +if version() < (2,9,1): + if platform.system() == "Windows": + libcpath = ctypes.util.find_library("msvcrt") + else: + libcpath = ctypes.util.find_library("c") + libc = CDLL(libcpath) + libc.free.argtypes = [c_void_p] + libc.free.restype = None + + def FT_Done_MM_Var_func(p): + libc.free(p) +else: + def FT_Done_MM_Var_func(p): + error = FT_Done_MM_Var(get_handle(), p) + if error: + raise FT_Exception("Failure calling FT_Done_MM_Var") + + +# ----------------------------------------------------------------------------- +class BBox( object ): + ''' + FT_BBox wrapper. + + A structure used to hold an outline's bounding box, i.e., the coordinates + of its extrema in the horizontal and vertical directions. + + **Note** + + The bounding box is specified with the coordinates of the lower left and + the upper right corner. In PostScript, those values are often called + (llx,lly) and (urx,ury), respectively. + + If 'yMin' is negative, this value gives the glyph's descender. Otherwise, + the glyph doesn't descend below the baseline. Similarly, if 'ymax' is + positive, this value gives the glyph's ascender. + + 'xMin' gives the horizontal distance from the glyph's origin to the left + edge of the glyph's bounding box. If 'xMin' is negative, the glyph + extends to the left of the origin. + ''' + + def __init__(self, bbox): + ''' + Create a new BBox object. + + :param bbox: a FT_BBox or a tuple of 4 values + ''' + if type(bbox) is FT_BBox: + self._FT_BBox = bbox + else: + self._FT_BBox = FT_BBox(*bbox) + + xMin = property(lambda self: self._FT_BBox.xMin, + doc = 'The horizontal minimum (left-most).') + + yMin = property(lambda self: self._FT_BBox.yMin, + doc = 'The vertical minimum (bottom-most).') + + xMax = property(lambda self: self._FT_BBox.xMax, + doc = 'The horizontal maximum (right-most).') + + yMax = property(lambda self: self._FT_BBox.yMax, + doc = 'The vertical maximum (top-most).') + + + + + +# ----------------------------------------------------------------------------- +class GlyphMetrics( object ): + ''' + + A structure used to model the metrics of a single glyph. The values are + expressed in 26.6 fractional pixel format; if the flag FT_LOAD_NO_SCALE has + been used while loading the glyph, values are expressed in font units + instead. + + **Note** + + If not disabled with FT_LOAD_NO_HINTING, the values represent dimensions of + the hinted glyph (in case hinting is applicable). + + Stroking a glyph with an outside border does not increase ‘horiAdvance’ or + ‘vertAdvance’; you have to manually adjust these values to account for the + added width and height. + ''' + + def __init__(self, metrics ): + ''' + Create a new GlyphMetrics object. + + :param metrics: a FT_Glyph_Metrics + ''' + self._FT_Glyph_Metrics = metrics + + width = property( lambda self: self._FT_Glyph_Metrics.width, + doc = '''The glyph's width.''' ) + + height = property( lambda self: self._FT_Glyph_Metrics.height, + doc = '''The glyph's height.''' ) + + horiBearingX = property( lambda self: self._FT_Glyph_Metrics.horiBearingX, + doc = '''Left side bearing for horizontal layout.''' ) + + horiBearingY = property( lambda self: self._FT_Glyph_Metrics.horiBearingY, + doc = '''Top side bearing for horizontal layout.''' ) + + horiAdvance = property( lambda self: self._FT_Glyph_Metrics.horiAdvance, + doc = '''Advance width for horizontal layout.''' ) + + vertBearingX = property( lambda self: self._FT_Glyph_Metrics.vertBearingX, + doc = '''Left side bearing for vertical layout.''' ) + + vertBearingY = property( lambda self: self._FT_Glyph_Metrics.vertBearingY, + doc = '''Top side bearing for vertical layout. Larger positive values + mean further below the vertical glyph origin.''' ) + + vertAdvance = property( lambda self: self._FT_Glyph_Metrics.vertAdvance, + doc = '''Advance height for vertical layout. Positive values mean the + glyph has a positive advance downward.''' ) + + +# ----------------------------------------------------------------------------- +class SizeMetrics( object ): + ''' + The size metrics structure gives the metrics of a size object. + + **Note** + + The scaling values, if relevant, are determined first during a size + changing operation. The remaining fields are then set by the driver. For + scalable formats, they are usually set to scaled values of the + corresponding fields in Face. + + Note that due to glyph hinting, these values might not be exact for certain + fonts. Thus they must be treated as unreliable with an error margin of at + least one pixel! + + Indeed, the only way to get the exact metrics is to render all glyphs. As + this would be a definite performance hit, it is up to client applications + to perform such computations. + + The SizeMetrics structure is valid for bitmap fonts also. + ''' + + def __init__(self, metrics ): + ''' + Create a new SizeMetrics object. + + :param metrics: a FT_SizeMetrics + ''' + self._FT_Size_Metrics = metrics + + x_ppem = property( lambda self: self._FT_Size_Metrics.x_ppem, + doc = '''The width of the scaled EM square in pixels, hence the term + 'ppem' (pixels per EM). It is also referred to as 'nominal + width'.''' ) + + y_ppem = property( lambda self: self._FT_Size_Metrics.y_ppem, + doc = '''The height of the scaled EM square in pixels, hence the term + 'ppem' (pixels per EM). It is also referred to as 'nominal + height'.''' ) + + x_scale = property( lambda self: self._FT_Size_Metrics.x_scale, + doc = '''A 16.16 fractional scaling value used to convert horizontal + metrics from font units to 26.6 fractional pixels. Only + relevant for scalable font formats.''' ) + + y_scale = property( lambda self: self._FT_Size_Metrics.y_scale, + doc = '''A 16.16 fractional scaling value used to convert vertical + metrics from font units to 26.6 fractional pixels. Only + relevant for scalable font formats.''' ) + + ascender = property( lambda self: self._FT_Size_Metrics.ascender, + doc = '''The ascender in 26.6 fractional pixels. See Face for the + details.''' ) + + descender = property( lambda self: self._FT_Size_Metrics.descender, + doc = '''The descender in 26.6 fractional pixels. See Face for the + details.''' ) + + height = property( lambda self: self._FT_Size_Metrics.height, + doc = '''The height in 26.6 fractional pixels. See Face for the details.''' ) + + max_advance = property(lambda self: self._FT_Size_Metrics.max_advance, + doc = '''The maximal advance width in 26.6 fractional pixels. See + Face for the details.''' ) + + + +# ----------------------------------------------------------------------------- +class BitmapSize( object ): + ''' + FT_Bitmap_Size wrapper + + This structure models the metrics of a bitmap strike (i.e., a set of glyphs + for a given point size and resolution) in a bitmap font. It is used for the + 'available_sizes' field of Face. + + **Note** + + Windows FNT: The nominal size given in a FNT font is not reliable. Thus + when the driver finds it incorrect, it sets 'size' to some calculated + values and sets 'x_ppem' and 'y_ppem' to the pixel width and height given + in the font, respectively. + + TrueType embedded bitmaps: 'size', 'width', and 'height' values are not + contained in the bitmap strike itself. They are computed from the global + font parameters. + ''' + def __init__(self, size ): + ''' + Create a new SizeMetrics object. + + :param size: a FT_Bitmap_Size + ''' + self._FT_Bitmap_Size = size + + height = property( lambda self: self._FT_Bitmap_Size.height, + doc = '''The vertical distance, in pixels, between two consecutive + baselines. It is always positive.''') + + width = property( lambda self: self._FT_Bitmap_Size.width, + doc = '''The average width, in pixels, of all glyphs in the strike.''') + + size = property( lambda self: self._FT_Bitmap_Size.size, + doc = '''The nominal size of the strike in 26.6 fractional points. This + field is not very useful.''') + + x_ppem = property( lambda self: self._FT_Bitmap_Size.x_ppem, + doc = '''The horizontal ppem (nominal width) in 26.6 fractional + pixels.''') + + y_ppem = property( lambda self: self._FT_Bitmap_Size.y_ppem, + doc = '''The vertical ppem (nominal width) in 26.6 fractional + pixels.''') + + +# ----------------------------------------------------------------------------- +class Bitmap(object): + ''' + FT_Bitmap wrapper + + A structure used to describe a bitmap or pixmap to the raster. Note that we + now manage pixmaps of various depths through the 'pixel_mode' field. + + *Note*: + + For now, the only pixel modes supported by FreeType are mono and + grays. However, drivers might be added in the future to support more + 'colorful' options. + ''' + def __init__(self, bitmap): + ''' + Create a new Bitmap object. + + :param bitmap: a FT_Bitmap + ''' + self._FT_Bitmap = bitmap + + rows = property(lambda self: self._FT_Bitmap.rows, + doc = '''The number of bitmap rows.''') + + width = property(lambda self: self._FT_Bitmap.width, + doc = '''The number of pixels in bitmap row.''') + + pitch = property(lambda self: self._FT_Bitmap.pitch, + doc = '''The pitch's absolute value is the number of bytes taken by one + bitmap row, including padding. However, the pitch is positive + when the bitmap has a 'down' flow, and negative when it has an + 'up' flow. In all cases, the pitch is an offset to add to a + bitmap pointer in order to go down one row. + + Note that 'padding' means the alignment of a bitmap to a byte + border, and FreeType functions normally align to the smallest + possible integer value. + + For the B/W rasterizer, 'pitch' is always an even number. + + To change the pitch of a bitmap (say, to make it a multiple of + 4), use FT_Bitmap_Convert. Alternatively, you might use callback + functions to directly render to the application's surface; see + the file 'example2.py' in the tutorial for a demonstration.''') + + def _get_buffer(self): + data = [self._FT_Bitmap.buffer[i] for i in range(self.rows*self.pitch)] + return data + buffer = property(_get_buffer, + doc = '''A typeless pointer to the bitmap buffer. This value should be + aligned on 32-bit boundaries in most cases.''') + + num_grays = property(lambda self: self._FT_Bitmap.num_grays, + doc = '''This field is only used with FT_PIXEL_MODE_GRAY; it gives + the number of gray levels used in the bitmap.''') + + pixel_mode = property(lambda self: self._FT_Bitmap.pixel_mode, + doc = '''The pixel mode, i.e., how pixel bits are stored. See + FT_Pixel_Mode for possible values.''') + + palette_mode = property(lambda self: self._FT_Bitmap.palette_mode, + doc ='''This field is intended for paletted pixel modes; it + indicates how the palette is stored. Not used currently.''') + + palette = property(lambda self: self._FT_Bitmap.palette, + doc = '''A typeless pointer to the bitmap palette; this field is + intended for paletted pixel modes. Not used currently.''') + + + + +# ----------------------------------------------------------------------------- +class Charmap( object ): + ''' + FT_Charmap wrapper. + + A handle to a given character map. A charmap is used to translate character + codes in a given encoding into glyph indexes for its parent's face. Some + font formats may provide several charmaps per font. + + Each face object owns zero or more charmaps, but only one of them can be + 'active' and used by FT_Get_Char_Index or FT_Load_Char. + + The list of available charmaps in a face is available through the + 'face.num_charmaps' and 'face.charmaps' fields of FT_FaceRec. + + The currently active charmap is available as 'face.charmap'. You should + call FT_Set_Charmap to change it. + + **Note**: + + When a new face is created (either through FT_New_Face or FT_Open_Face), + the library looks for a Unicode charmap within the list and automatically + activates it. + + **See also**: + + See FT_CharMapRec for the publicly accessible fields of a given character + map. + ''' + + def __init__( self, charmap ): + ''' + Create a new Charmap object. + + Parameters: + ----------- + charmap : a FT_Charmap + ''' + self._FT_Charmap = charmap + + encoding = property( lambda self: self._FT_Charmap.contents.encoding, + doc = '''An FT_Encoding tag identifying the charmap. Use this with + FT_Select_Charmap.''') + + platform_id = property( lambda self: self._FT_Charmap.contents.platform_id, + doc = '''An ID number describing the platform for the following + encoding ID. This comes directly from the TrueType + specification and should be emulated for other + formats.''') + + encoding_id = property( lambda self: self._FT_Charmap.contents.encoding_id, + doc = '''A platform specific encoding number. This also comes from + the TrueType specification and should be emulated + similarly.''') + + def _get_encoding_name(self): + encoding = self.encoding + for key,value in FT_ENCODINGS.items(): + if encoding == value: + return key + return 'Unknown encoding' + encoding_name = property( _get_encoding_name, + doc = '''A platform specific encoding name. This also comes from + the TrueType specification and should be emulated + similarly.''') + + def _get_index( self ): + return FT_Get_Charmap_Index( self._FT_Charmap ) + index = property( _get_index, + doc = '''The index into the array of character maps within the face to + which 'charmap' belongs. If an error occurs, -1 is returned.''') + + def _get_cmap_language_id( self ): + return FT_Get_CMap_Language_ID( self._FT_Charmap ) + cmap_language_id = property( _get_cmap_language_id, + doc = '''The language ID of 'charmap'. If 'charmap' doesn't + belong to a TrueType/sfnt face, just return 0 as the + default value.''') + + def _get_cmap_format( self ): + return FT_Get_CMap_Format( self._FT_Charmap ) + cmap_format = property( _get_cmap_format, + doc = '''The format of 'charmap'. If 'charmap' doesn't belong to a + TrueType/sfnt face, return -1.''') + + + +# ----------------------------------------------------------------------------- +class Outline( object ): + ''' + FT_Outline wrapper. + + This structure is used to describe an outline to the scan-line converter. + ''' + def __init__( self, outline ): + ''' + Create a new Outline object. + + :param charmap: a FT_Outline + ''' + self._FT_Outline = outline + + n_contours = property(lambda self: self._FT_Outline.n_contours) + def _get_contours(self): + n = self._FT_Outline.n_contours + data = [self._FT_Outline.contours[i] for i in range(n)] + return data + contours = property(_get_contours, + doc = '''The number of contours in the outline.''') + + n_points = property(lambda self: self._FT_Outline.n_points) + def _get_points(self): + n = self._FT_Outline.n_points + data = [] + for i in range(n): + v = self._FT_Outline.points[i] + data.append( (v.x,v.y) ) + return data + points = property( _get_points, + doc = '''The number of points in the outline.''') + + def _get_tags(self): + n = self._FT_Outline.n_points + data = [self._FT_Outline.tags[i] for i in range(n)] + return data + tags = property(_get_tags, + doc = '''A list of 'n_points' chars, giving each outline point's type. + + If bit 0 is unset, the point is 'off' the curve, i.e., a Bezier + control point, while it is 'on' if set. + + Bit 1 is meaningful for 'off' points only. If set, it indicates a + third-order Bezier arc control point; and a second-order control + point if unset. + + If bit 2 is set, bits 5-7 contain the drop-out mode (as defined + in the OpenType specification; the value is the same as the + argument to the SCANMODE instruction). + + Bits 3 and 4 are reserved for internal purposes.''') + + flags = property(lambda self: self._FT_Outline.flags, + doc = '''A set of bit flags used to characterize the outline and give + hints to the scan-converter and hinter on how to + convert/grid-fit it. See FT_OUTLINE_FLAGS.''') + + def get_inside_border( self ): + ''' + Retrieve the FT_StrokerBorder value corresponding to the 'inside' + borders of a given outline. + + :return: The border index. FT_STROKER_BORDER_RIGHT for empty or invalid + outlines. + ''' + return FT_Outline_GetInsideBorder( byref(self._FT_Outline) ) + + def get_outside_border( self ): + ''' + Retrieve the FT_StrokerBorder value corresponding to the 'outside' + borders of a given outline. + + :return: The border index. FT_STROKER_BORDER_RIGHT for empty or invalid + outlines. + ''' + return FT_Outline_GetOutsideBorder( byref(self._FT_Outline) ) + + def get_bbox(self): + ''' + Compute the exact bounding box of an outline. This is slower than + computing the control box. However, it uses an advanced algorithm which + returns very quickly when the two boxes coincide. Otherwise, the + outline Bezier arcs are traversed to extract their extrema. + ''' + bbox = FT_BBox() + error = FT_Outline_Get_BBox(byref(self._FT_Outline), byref(bbox)) + if error: raise FT_Exception(error) + return BBox(bbox) + + def get_cbox(self): + ''' + Return an outline's 'control box'. The control box encloses all the + outline's points, including Bezier control points. Though it coincides + with the exact bounding box for most glyphs, it can be slightly larger + in some situations (like when rotating an outline which contains Bezier + outside arcs). + + Computing the control box is very fast, while getting the bounding box + can take much more time as it needs to walk over all segments and arcs + in the outline. To get the latter, you can use the 'ftbbox' component + which is dedicated to this single task. + ''' + bbox = FT_BBox() + FT_Outline_Get_CBox(byref(self._FT_Outline), byref(bbox)) + return BBox(bbox) + + _od_move_to_noop = FT_Outline_MoveToFunc(lambda a, b: 0) + def _od_move_to_builder(self, cb): + if cb is None: + return self._od_move_to_noop + def move_to(a, b): + return cb(a[0], b) or 0 + return FT_Outline_MoveToFunc(move_to) + + _od_line_to_noop = FT_Outline_LineToFunc(lambda a, b: 0) + def _od_line_to_builder(self, cb): + if cb is None: + return self._od_line_to_noop + def line_to(a, b): + return cb(a[0], b) or 0 + return FT_Outline_LineToFunc(line_to) + + _od_conic_to_noop = FT_Outline_ConicToFunc(lambda a, b, c: 0) + def _od_conic_to_builder(self, cb): + if cb is None: + return self._od_conic_to_noop + def conic_to(a, b, c): + return cb(a[0], b[0], c) or 0 + return FT_Outline_ConicToFunc(conic_to) + + _od_cubic_to_noop = FT_Outline_CubicToFunc(lambda a, b, c, d: 0) + def _od_cubic_to_builder(self, cb): + if cb is None: + return self._od_cubic_to_noop + def cubic_to(a, b, c, d): + return cb(a[0], b[0], c[0], d) or 0 + return FT_Outline_CubicToFunc(cubic_to) + + def decompose(self, context=None, move_to=None, line_to=None, conic_to=None, cubic_to=None, shift=0, delta=0): + ''' + Decompose the outline into a sequence of move, line, conic, and + cubic segments. + + :param context: Arbitrary contextual object which will be passed as + the last parameter of all callbacks. Typically an + object to be drawn to, but can be anything. + + :param move_to: Callback which will be passed an `FT_Vector` + control point and the context. Called when outline + needs to jump to a new path component. + + :param line_to: Callback which will be passed an `FT_Vector` + control point and the context. Called to draw a + straight line from the current position to the + control point. + + :param conic_to: Callback which will be passed two `FT_Vector` + control points and the context. Called to draw a + second-order Bézier curve from the current + position using the passed control points. + + :param curve_to: Callback which will be passed three `FT_Vector` + control points and the context. Called to draw a + third-order Bézier curve from the current position + using the passed control points. + + :param shift: Passed to FreeType which will transform vectors via + `x = (x << shift) - delta` and `y = (y << shift) - delta` + + :param delta: Passed to FreeType which will transform vectors via + `x = (x << shift) - delta` and `y = (y << shift) - delta` + + :since: 1.3 + ''' + func = FT_Outline_Funcs( + move_to = self._od_move_to_builder(move_to), + line_to = self._od_line_to_builder(line_to), + conic_to = self._od_conic_to_builder(conic_to), + cubic_to = self._od_cubic_to_builder(cubic_to), + shift = shift, + delta = FT_Pos(delta), + ) + + error = FT_Outline_Decompose( byref(self._FT_Outline), byref(func), py_object(context) ) + if error: raise FT_Exception( error ) + + + +# ----------------------------------------------------------------------------- +class Glyph( object ): + ''' + FT_Glyph wrapper. + + The root glyph structure contains a given glyph image plus its advance + width in 16.16 fixed float format. + ''' + def __init__( self, glyph ): + ''' + Create Glyph object from an FT glyph. + + :param glyph: valid FT_Glyph object + ''' + self._FT_Glyph = glyph + + def __del__( self ): + ''' + Destroy glyph. + ''' + FT_Done_Glyph( self._FT_Glyph ) + + def _get_format( self ): + return self._FT_Glyph.contents.format + format = property( _get_format, + doc = '''The format of the glyph's image.''') + + + def stroke( self, stroker, destroy=False ): + ''' + Stroke a given outline glyph object with a given stroker. + + :param stroker: A stroker handle. + + :param destroy: A Boolean. If 1, the source glyph object is destroyed on + success. + + **Note**: + + The source glyph is untouched in case of error. + ''' + error = FT_Glyph_Stroke( byref(self._FT_Glyph), + stroker._FT_Stroker, destroy ) + if error: raise FT_Exception( error ) + + def to_bitmap( self, mode, origin, destroy=False ): + ''' + Convert a given glyph object to a bitmap glyph object. + + :param mode: An enumeration that describes how the data is rendered. + + :param origin: A pointer to a vector used to translate the glyph image + before rendering. Can be 0 (if no translation). The origin is + expressed in 26.6 pixels. + + We also detect a plain vector and make a pointer out of it, + if that's the case. + + :param destroy: A boolean that indicates that the original glyph image + should be destroyed by this function. It is never destroyed + in case of error. + + **Note**: + + This function does nothing if the glyph format isn't scalable. + + The glyph image is translated with the 'origin' vector before + rendering. + + The first parameter is a pointer to an FT_Glyph handle, that will be + replaced by this function (with newly allocated data). Typically, you + would use (omitting error handling): + ''' + if ( type(origin) == FT_Vector ): + error = FT_Glyph_To_Bitmap( byref(self._FT_Glyph), + mode, byref(origin), destroy ) + else: + error = FT_Glyph_To_Bitmap( byref(self._FT_Glyph), + mode, origin, destroy ) + + if error: raise FT_Exception( error ) + return BitmapGlyph( self._FT_Glyph ) + + def get_cbox(self, bbox_mode): + ''' + Return an outline's 'control box'. The control box encloses all the + outline's points, including Bezier control points. Though it coincides + with the exact bounding box for most glyphs, it can be slightly larger + in some situations (like when rotating an outline which contains Bezier + outside arcs). + + Computing the control box is very fast, while getting the bounding box + can take much more time as it needs to walk over all segments and arcs + in the outline. To get the latter, you can use the 'ftbbox' component + which is dedicated to this single task. + + :param mode: The mode which indicates how to interpret the returned + bounding box values. + + **Note**: + + Coordinates are relative to the glyph origin, using the y upwards + convention. + + If the glyph has been loaded with FT_LOAD_NO_SCALE, 'bbox_mode' must be + set to FT_GLYPH_BBOX_UNSCALED to get unscaled font units in 26.6 pixel + format. The value FT_GLYPH_BBOX_SUBPIXELS is another name for this + constant. + + Note that the maximum coordinates are exclusive, which means that one + can compute the width and height of the glyph image (be it in integer + or 26.6 pixels) as: + + width = bbox.xMax - bbox.xMin; + height = bbox.yMax - bbox.yMin; + + Note also that for 26.6 coordinates, if 'bbox_mode' is set to + FT_GLYPH_BBOX_GRIDFIT, the coordinates will also be grid-fitted, which + corresponds to: + + bbox.xMin = FLOOR(bbox.xMin); + bbox.yMin = FLOOR(bbox.yMin); + bbox.xMax = CEILING(bbox.xMax); + bbox.yMax = CEILING(bbox.yMax); + + To get the bbox in pixel coordinates, set 'bbox_mode' to + FT_GLYPH_BBOX_TRUNCATE. + + To get the bbox in grid-fitted pixel coordinates, set 'bbox_mode' to + FT_GLYPH_BBOX_PIXELS. + ''' + bbox = FT_BBox() + FT_Glyph_Get_CBox(byref(self._FT_Glyph.contents), bbox_mode, byref(bbox)) + return BBox(bbox) + + + +# ----------------------------------------------------------------------------- +class BitmapGlyph( object ): + ''' + FT_BitmapGlyph wrapper. + + A structure used for bitmap glyph images. This really is a 'sub-class' of + FT_GlyphRec. + ''' + def __init__( self, glyph ): + ''' + Create Glyph object from an FT glyph. + + Parameters: + ----------- + glyph: valid FT_Glyph object + ''' + self._FT_BitmapGlyph = cast(glyph, FT_BitmapGlyph) + + # def __del__( self ): + # ''' + # Destroy glyph. + # ''' + # FT_Done_Glyph( cast(self._FT_BitmapGlyph, FT_Glyph) ) + + + def _get_format( self ): + return self._FT_BitmapGlyph.contents.format + format = property( _get_format, + doc = '''The format of the glyph's image.''') + + + def _get_bitmap( self ): + return Bitmap( self._FT_BitmapGlyph.contents.bitmap ) + bitmap = property( _get_bitmap, + doc = '''A descriptor for the bitmap.''') + + + def _get_left( self ): + return self._FT_BitmapGlyph.contents.left + left = property( _get_left, + doc = '''The left-side bearing, i.e., the horizontal distance from the + current pen position to the left border of the glyph bitmap.''') + + + def _get_top( self ): + return self._FT_BitmapGlyph.contents.top + top = property( _get_top, + doc = '''The top-side bearing, i.e., the vertical distance from the + current pen position to the top border of the glyph bitmap. + This distance is positive for upwards y!''') + + +# ----------------------------------------------------------------------------- +class GlyphSlot( object ): + ''' + FT_GlyphSlot wrapper. + + FreeType root glyph slot class structure. A glyph slot is a container where + individual glyphs can be loaded, be they in outline or bitmap format. + ''' + + def __init__( self, slot ): + ''' + Create GlyphSlot object from an FT glyph slot. + + Parameters: + ----------- + glyph: valid FT_GlyphSlot object + ''' + self._FT_GlyphSlot = slot + + def render( self, render_mode ): + ''' + Convert a given glyph image to a bitmap. It does so by inspecting the + glyph image format, finding the relevant renderer, and invoking it. + + :param render_mode: The render mode used to render the glyph image into + a bitmap. See FT_Render_Mode for a list of possible + values. + + If FT_RENDER_MODE_NORMAL is used, a previous call + of FT_Load_Glyph with flag FT_LOAD_COLOR makes + FT_Render_Glyph provide a default blending of + colored glyph layers associated with the current + glyph slot (provided the font contains such layers) + instead of rendering the glyph slot's outline. + This is an experimental feature; see FT_LOAD_COLOR + for more information. + + **Note**: + + To get meaningful results, font scaling values must be set with + functions like FT_Set_Char_Size before calling FT_Render_Glyph. + + When FreeType outputs a bitmap of a glyph, it really outputs an alpha + coverage map. If a pixel is completely covered by a filled-in + outline, the bitmap contains 0xFF at that pixel, meaning that + 0xFF/0xFF fraction of that pixel is covered, meaning the pixel is + 100% black (or 0% bright). If a pixel is only 50% covered + (value 0x80), the pixel is made 50% black (50% bright or a middle + shade of grey). 0% covered means 0% black (100% bright or white). + + On high-DPI screens like on smartphones and tablets, the pixels are + so small that their chance of being completely covered and therefore + completely black are fairly good. On the low-DPI screens, however, + the situation is different. The pixels are too large for most of the + details of a glyph and shades of gray are the norm rather than the + exception. + + This is relevant because all our screens have a second problem: they + are not linear. 1 + 1 is not 2. Twice the value does not result in + twice the brightness. When a pixel is only 50% covered, the coverage + map says 50% black, and this translates to a pixel value of 128 when + you use 8 bits per channel (0-255). However, this does not translate + to 50% brightness for that pixel on our sRGB and gamma 2.2 screens. + Due to their non-linearity, they dwell longer in the darks and only a + pixel value of about 186 results in 50% brightness – 128 ends up too + dark on both bright and dark backgrounds. The net result is that dark + text looks burnt-out, pixely and blotchy on bright background, bright + text too frail on dark backgrounds, and colored text on colored + background (for example, red on green) seems to have dark halos or + ‘dirt’ around it. The situation is especially ugly for diagonal stems + like in ‘w’ glyph shapes where the quality of FreeType's + anti-aliasing depends on the correct display of grays. On high-DPI + screens where smaller, fully black pixels reign supreme, this doesn't + matter, but on our low-DPI screens with all the gray shades, it does. + 0% and 100% brightness are the same things in linear and non-linear + space, just all the shades in-between aren't. + + The blending function for placing text over a background is + + dst = alpha * src + (1 - alpha) * dst + + which is known as the OVER operator. + + To correctly composite an anti-aliased pixel of a glyph onto a + surface, take the foreground and background colors (e.g., in sRGB + space) and apply gamma to get them in a linear space, use OVER to + blend the two linear colors using the glyph pixel as the alpha value + (remember, the glyph bitmap is an alpha coverage bitmap), and apply + inverse gamma to the blended pixel and write it back to the image. + + Internal testing at Adobe found that a target inverse gamma of 1.8 + for step 3 gives good results across a wide range of displays with + an sRGB gamma curve or a similar one. + + This process can cost performance. There is an approximation that + does not need to know about the background color; see + https://bel.fi/alankila/lcd/ and + https://bel.fi/alankila/lcd/alpcor.html for details. + + **ATTENTION:** Linear blending is even more important when dealing + with subpixel-rendered glyphs to prevent color-fringing! A + subpixel-rendered glyph must first be filtered with a filter that + gives equal weight to the three color primaries and does not exceed a + sum of 0x100, see section ‘Subpixel Rendering’. Then the only + difference to gray linear blending is that subpixel-rendered linear + blending is done 3 times per pixel: red foreground subpixel to red + background subpixel and so on for green and blue. + ''' + error = FT_Render_Glyph( self._FT_GlyphSlot, render_mode ) + if error: raise FT_Exception( error ) + + def get_glyph( self ): + ''' + A function used to extract a glyph image from a slot. Note that the + created FT_Glyph object must be released with FT_Done_Glyph. + ''' + aglyph = FT_Glyph() + error = FT_Get_Glyph( self._FT_GlyphSlot, byref(aglyph) ) + if error: raise FT_Exception( error ) + return Glyph( aglyph ) + + def _get_bitmap( self ): + return Bitmap( self._FT_GlyphSlot.contents.bitmap ) + bitmap = property( _get_bitmap, + doc = '''This field is used as a bitmap descriptor when the slot format + is FT_GLYPH_FORMAT_BITMAP. Note that the address and content of + the bitmap buffer can change between calls of FT_Load_Glyph and + a few other functions.''') + + def _get_metrics( self ): + return GlyphMetrics( self._FT_GlyphSlot.contents.metrics ) + metrics = property( _get_metrics, + doc = '''The metrics of the last loaded glyph in the slot. The returned + values depend on the last load flags (see the FT_Load_Glyph API + function) and can be expressed either in 26.6 fractional pixels or font + units. Note that even when the glyph image is transformed, the metrics + are not.''') + + def _get_next( self ): + return GlyphSlot( self._FT_GlyphSlot.contents.next ) + next = property( _get_next, + doc = '''In some cases (like some font tools), several glyph slots per + face object can be a good thing. As this is rare, the glyph slots + are listed through a direct, single-linked list using its 'next' + field.''') + + advance = property( lambda self: self._FT_GlyphSlot.contents.advance, + doc = '''This shorthand is, depending on FT_LOAD_IGNORE_TRANSFORM, the + transformed advance width for the glyph (in 26.6 fractional + pixel format). As specified with FT_LOAD_VERTICAL_LAYOUT, it + uses either the 'horiAdvance' or the 'vertAdvance' value of + 'metrics' field.''') + + def _get_outline( self ): + return Outline( self._FT_GlyphSlot.contents.outline ) + outline = property( _get_outline, + doc = '''The outline descriptor for the current glyph image if its + format is FT_GLYPH_FORMAT_OUTLINE. Once a glyph is loaded, + 'outline' can be transformed, distorted, embolded, + etc. However, it must not be freed.''') + + format = property( lambda self: self._FT_GlyphSlot.contents.format, + doc = '''This field indicates the format of the image contained in the + glyph slot. Typically FT_GLYPH_FORMAT_BITMAP, + FT_GLYPH_FORMAT_OUTLINE, or FT_GLYPH_FORMAT_COMPOSITE, but + others are possible.''') + + bitmap_top = property( lambda self: + self._FT_GlyphSlot.contents.bitmap_top, + doc = '''This is the bitmap's top bearing expressed in integer + pixels. Remember that this is the distance from the + baseline to the top-most glyph scanline, upwards y + coordinates being positive.''') + + bitmap_left = property( lambda self: + self._FT_GlyphSlot.contents.bitmap_left, + doc = '''This is the bitmap's left bearing expressed in integer + pixels. Of course, this is only valid if the format is + FT_GLYPH_FORMAT_BITMAP.''') + + linearHoriAdvance = property( lambda self: + self._FT_GlyphSlot.contents.linearHoriAdvance, + doc = '''The advance width of the unhinted glyph. Its value + is expressed in 16.16 fractional pixels, unless + FT_LOAD_LINEAR_DESIGN is set when loading the glyph. + This field can be important to perform correct + WYSIWYG layout. Only relevant for outline glyphs.''') + + linearVertAdvance = property( lambda self: + self._FT_GlyphSlot.contents.linearVertAdvance, + doc = '''The advance height of the unhinted glyph. Its value + is expressed in 16.16 fractional pixels, unless + FT_LOAD_LINEAR_DESIGN is set when loading the glyph. + This field can be important to perform correct + WYSIWYG layout. Only relevant for outline glyphs.''') + + +# ----------------------------------------------------------------------------- +# Face wrapper +# ----------------------------------------------------------------------------- +class Face( object ): + ''' + FT_Face wrapper + + FreeType root face class structure. A face object models a typeface in a + font file. + ''' + def __init__( self, path_or_stream, index = 0 ): + ''' + Build a new Face + + :param Union[str, typing.BinaryIO] path_or_stream: + A path to the font file or an io.BytesIO stream. + + :param int index: + The index of the face within the font. + The first face has index 0. + ''' + library = get_handle( ) + face = FT_Face( ) + self._FT_Face = None + #error = FT_New_Face( library, path_or_stream, 0, byref(face) ) + self._filebodys = [] + if hasattr(path_or_stream, "read"): + error = self._init_from_memory(library, face, index, path_or_stream.read()) + else: + try: + error = self._init_from_file(library, face, index, path_or_stream) + except UnicodeError: + with open(path_or_stream, mode="rb") as f: + filebody = f.read() + error = self._init_from_memory(library, face, index, filebody) + if error: + raise FT_Exception(error) + self._index = index + self._FT_Face = face + self._name_strings = dict() + + def _init_from_file(self, library, face, index, path): + u_filename = c_char_p(_encode_filename(path)) + error = FT_New_Face(library, u_filename, index, byref(face)) + return error + + def _init_from_memory(self, library, face, index, byte_stream): + error = FT_New_Memory_Face( + library, byte_stream, len(byte_stream), index, byref(face) + ) + self._filebodys.append(byte_stream) # prevent gc + return error + + def _init_name_string_map(self): + # build map of (nID, pID, eID, lID) keys to name string bytes + self._name_strings = dict() + + for nidx in range(self._get_sfnt_name_count()): + namerec = self.get_sfnt_name(nidx) + nk = (namerec.name_id, + namerec.platform_id, + namerec.encoding_id, + namerec.language_id) + + self._name_strings[nk] = namerec.string + + @classmethod + def from_bytes(cls, bytes_, index=0): + return cls(io.BytesIO(bytes_), index) + + def __del__( self ): + ''' + Discard face object, as well as all of its child slots and sizes. + ''' + # We check FT_Done_Face because by the time we're called it + # may already be gone (see #44 and discussion in #169) + if FT_Done_Face is not None and self._FT_Face is not None: + FT_Done_Face( self._FT_Face ) + + + def attach_file( self, filename ): + ''' + Attach data to a face object. Normally, this is used to read + additional information for the face object. For example, you can attach + an AFM file that comes with a Type 1 font to get the kerning values and + other metrics. + + :param filename: Filename to attach + + **Note** + + The meaning of the 'attach' (i.e., what really happens when the new + file is read) is not fixed by FreeType itself. It really depends on the + font format (and thus the font driver). + + Client applications are expected to know what they are doing when + invoking this function. Most drivers simply do not implement file + attachments. + ''' + + try: + u_filename = c_char_p(_encode_filename(filename)) + error = FT_Attach_File( self._FT_Face, u_filename ) + except UnicodeError: + with open(filename, mode='rb') as f: + filebody = f.read() + parameters = FT_Open_Args() + parameters.flags = FT_OPEN_MEMORY + parameters.memory_base = filebody + parameters.memory_size = len(filebody) + parameters.stream = None + error = FT_Attach_Stream( self._FT_Face, parameters ) + self._filebodys.append(filebody) # prevent gc + if error: raise FT_Exception( error) + + + def set_char_size( self, width=0, height=0, hres=72, vres=72 ): + ''' + This function calls FT_Request_Size to request the nominal size (in + points). + + :param float width: The nominal width, in 26.6 fractional points. + + :param float height: The nominal height, in 26.6 fractional points. + + :param float hres: The horizontal resolution in dpi. + + :param float vres: The vertical resolution in dpi. + + **Note** + + If either the character width or height is zero, it is set equal to the + other value. + + If either the horizontal or vertical resolution is zero, it is set + equal to the other value. + + A character width or height smaller than 1pt is set to 1pt; if both + resolution values are zero, they are set to 72dpi. + + Don't use this function if you are using the FreeType cache API. + ''' + error = FT_Set_Char_Size( self._FT_Face, width, height, hres, vres ) + if error: raise FT_Exception( error) + + def set_pixel_sizes( self, width, height ): + ''' + This function calls FT_Request_Size to request the nominal size (in + pixels). + + :param width: The nominal width, in pixels. + + :param height: The nominal height, in pixels. + ''' + error = FT_Set_Pixel_Sizes( self._FT_Face, width, height ) + if error: raise FT_Exception(error) + + def select_charmap( self, encoding ): + ''' + Select a given charmap by its encoding tag (as listed in 'freetype.h'). + + **Note**: + + This function returns an error if no charmap in the face corresponds to + the encoding queried here. + + Because many fonts contain more than a single cmap for Unicode + encoding, this function has some special code to select the one which + covers Unicode best ('best' in the sense that a UCS-4 cmap is preferred + to a UCS-2 cmap). It is thus preferable to FT_Set_Charmap in this case. + ''' + error = FT_Select_Charmap( self._FT_Face, encoding ) + if error: raise FT_Exception(error) + + def set_charmap( self, charmap ): + ''' + Select a given charmap for character code to glyph index mapping. + + :param charmap: A handle to the selected charmap, or an index to face->charmaps[] + ''' + if ( type(charmap) == Charmap ): + error = FT_Set_Charmap( self._FT_Face, charmap._FT_Charmap ) + # Type 14 is allowed to fail, to match ft2demo's behavior. + if ( charmap.cmap_format == 14 ): + error = 0 + else: + # Treat "charmap" as plain number + error = FT_Set_Charmap( self._FT_Face, self._FT_Face.contents.charmaps[charmap] ) + if error : raise FT_Exception(error) + + def get_char_index( self, charcode ): + ''' + Return the glyph index of a given character code. This function uses a + charmap object to do the mapping. + + :param charcode: The character code. + + **Note**: + + If you use FreeType to manipulate the contents of font files directly, + be aware that the glyph index returned by this function doesn't always + correspond to the internal indices used within the file. This is done + to ensure that value 0 always corresponds to the 'missing glyph'. + ''' + if isinstance(charcode, (str,unicode)): + charcode = ord(charcode) + return FT_Get_Char_Index( self._FT_Face, charcode ) + + def get_glyph_name(self, agindex, buffer_max=64): + ''' + This function is used to return the glyph name for the given charcode. + + :param agindex: The glyph index. + + :param buffer_max: The maximum number of bytes to use to store the + glyph name. + + :param glyph_name: The glyph name, possibly truncated. + + ''' + buff = create_string_buffer(buffer_max) + error = FT_Get_Glyph_Name(self._FT_Face, FT_UInt(agindex), byref(buff), + FT_UInt(buffer_max)) + if error: raise FT_Exception(error) + return buff.value + + def get_chars( self ): + ''' + This generator function is used to return all unicode character + codes in the current charmap of a given face. For each character it + also returns the corresponding glyph index. + + :return: character code, glyph index + + **Note**: + Note that 'agindex' is set to 0 if the charmap is empty. The + character code itself can be 0 in two cases: if the charmap is empty + or if the value 0 is the first valid character code. + ''' + charcode, agindex = self.get_first_char() + yield charcode, agindex + while agindex != 0: + charcode, agindex = self.get_next_char(charcode, 0) + yield charcode, agindex + + def get_first_char( self ): + ''' + This function is used to return the first character code in the current + charmap of a given face. It also returns the corresponding glyph index. + + :return: Glyph index of first character code. 0 if charmap is empty. + + **Note**: + + You should use this function with get_next_char to be able to parse + all character codes available in a given charmap. The code should look + like this: + + Note that 'agindex' is set to 0 if the charmap is empty. The result + itself can be 0 in two cases: if the charmap is empty or if the value 0 + is the first valid character code. + ''' + agindex = FT_UInt() + charcode = FT_Get_First_Char( self._FT_Face, byref(agindex) ) + return charcode, agindex.value + + def get_next_char( self, charcode, agindex ): + ''' + This function is used to return the next character code in the current + charmap of a given face following the value 'charcode', as well as the + corresponding glyph index. + + :param charcode: The starting character code. + + :param agindex: Glyph index of next character code. 0 if charmap is empty. + + **Note**: + + You should use this function with FT_Get_First_Char to walk over all + character codes available in a given charmap. See the note for this + function for a simple code example. + + Note that 'agindex' is set to 0 when there are no more codes in the + charmap. + ''' + agindex = FT_UInt( 0 ) #agindex ) + charcode = FT_Get_Next_Char( self._FT_Face, charcode, byref(agindex) ) + return charcode, agindex.value + + def get_name_index( self, name ): + ''' + Return the glyph index of a given glyph name. This function uses driver + specific objects to do the translation. + + :param name: The glyph name. + ''' + if not isinstance(name, bytes): + raise FT_Exception(0x06, "FT_Get_Name_Index() expects a binary " + "string for the name parameter.") + return FT_Get_Name_Index( self._FT_Face, name ) + + def set_transform( self, matrix, delta ): + ''' + A function used to set the transformation that is applied to glyph + images when they are loaded into a glyph slot through FT_Load_Glyph. + + :param matrix: A pointer to the transformation's 2x2 matrix. + Use 0 for the identity matrix. + + :parm delta: A pointer to the translation vector. + Use 0 for the null vector. + + **Note**: + + The transformation is only applied to scalable image formats after the + glyph has been loaded. It means that hinting is unaltered by the + transformation and is performed on the character size given in the last + call to FT_Set_Char_Size or FT_Set_Pixel_Sizes. + + Note that this also transforms the 'face.glyph.advance' field, but + not the values in 'face.glyph.metrics'. + ''' + FT_Set_Transform( self._FT_Face, + byref(matrix), byref(delta) ) + + def select_size( self, strike_index ): + ''' + Select a bitmap strike. + + :param strike_index: The index of the bitmap strike in the + 'available_sizes' field of Face object. + ''' + error = FT_Select_Size( self._FT_Face, strike_index ) + if error: raise FT_Exception( error ) + + def load_glyph( self, index, flags = FT_LOAD_RENDER ): + ''' + A function used to load a single glyph into the glyph slot of a face + object. + + :param index: The index of the glyph in the font file. For CID-keyed + fonts (either in PS or in CFF format) this argument + specifies the CID value. + + :param flags: A flag indicating what to load for this glyph. The FT_LOAD_XXX + constants can be used to control the glyph loading process + (e.g., whether the outline should be scaled, whether to load + bitmaps or not, whether to hint the outline, etc). + + **Note**: + + The loaded glyph may be transformed. See FT_Set_Transform for the + details. + + For subsetted CID-keyed fonts, 'FT_Err_Invalid_Argument' is returned + for invalid CID values (this is, for CID values which don't have a + corresponding glyph in the font). See the discussion of the + FT_FACE_FLAG_CID_KEYED flag for more details. + ''' + error = FT_Load_Glyph( self._FT_Face, index, flags ) + if error: raise FT_Exception( error ) + + def load_char( self, char, flags = FT_LOAD_RENDER ): + ''' + A function used to load a single glyph into the glyph slot of a face + object, according to its character code. + + :param char: The glyph's character code, according to the current + charmap used in the face. + + :param flags: A flag indicating what to load for this glyph. The + FT_LOAD_XXX constants can be used to control the glyph + loading process (e.g., whether the outline should be + scaled, whether to load bitmaps or not, whether to hint + the outline, etc). + + **Note**: + + This function simply calls FT_Get_Char_Index and FT_Load_Glyph. + ''' + + # python 2 with ascii input + if ( isinstance(char, str) and ( len(char) == 1 ) ): + char = ord(char) + # python 2 with utf8 string input + if ( isinstance(char, str) and ( len(char) != 1 ) ): + char = ord(char.decode('utf8')) + # python 3 or python 2 with __future__.unicode_literals + if ( isinstance(char, unicode) and ( len(char) == 1 ) ): + char = ord(char) + # allow bare integer to pass through + error = FT_Load_Char( self._FT_Face, char, flags ) + if error: raise FT_Exception( error ) + + + def get_advance( self, gindex, flags ): + ''' + Retrieve the advance value of a given glyph outline in an FT_Face. By + default, the unhinted advance is returned in font units. + + :param gindex: The glyph index. + + :param flags: A set of bit flags similar to those used when calling + FT_Load_Glyph, used to determine what kind of advances + you need. + + :return: The advance value, in either font units or 16.16 format. + + If FT_LOAD_VERTICAL_LAYOUT is set, this is the vertical + advance corresponding to a vertical layout. Otherwise, it is + the horizontal advance in a horizontal layout. + ''' + + padvance = FT_Fixed(0) + error = FT_Get_Advance( self._FT_Face, gindex, flags, byref(padvance) ) + if error: raise FT_Exception( error ) + return padvance.value + + + + def get_kerning( self, left, right, mode = FT_KERNING_DEFAULT ): + ''' + Return the kerning vector between two glyphs of a same face. + + :param left: The index of the left glyph in the kern pair. + + :param right: The index of the right glyph in the kern pair. + + :param mode: See FT_Kerning_Mode for more information. Determines the scale + and dimension of the returned kerning vector. + + **Note**: + + Only horizontal layouts (left-to-right & right-to-left) are supported + by this method. Other layouts, or more sophisticated kernings, are out + of the scope of this API function -- they can be implemented through + format-specific interfaces. + ''' + left_glyph = self.get_char_index( left ) + right_glyph = self.get_char_index( right ) + kerning = FT_Vector(0,0) + error = FT_Get_Kerning( self._FT_Face, + left_glyph, right_glyph, mode, byref(kerning) ) + if error: raise FT_Exception( error ) + return kerning + + def get_format(self): + ''' + Return a string describing the format of a given face, using values + which can be used as an X11 FONT_PROPERTY. Possible values are + 'TrueType', 'Type 1', 'BDF', ‘PCF', ‘Type 42', ‘CID Type 1', ‘CFF', + 'PFR', and ‘Windows FNT'. + ''' + + return FT_Get_X11_Font_Format( self._FT_Face ) + + + def get_fstype(self): + ''' + Return the fsType flags for a font (embedding permissions). + + The return value is a tuple containing the freetype enum name + as a string and the actual flag as an int + ''' + + flag = FT_Get_FSType_Flags( self._FT_Face ) + for k, v in FT_FSTYPES.items(): + if v == flag: + return k, v + + + def _get_sfnt_name_count(self): + return FT_Get_Sfnt_Name_Count( self._FT_Face ) + sfnt_name_count = property(_get_sfnt_name_count, + doc = '''Number of name strings in the SFNT 'name' table.''') + + def get_sfnt_name( self, index ): + ''' + Retrieve a string of the SFNT 'name' table for a given index + + :param index: The index of the 'name' string. + + **Note**: + + The 'string' array returned in the 'aname' structure is not + null-terminated. The application should deallocate it if it is no + longer in use. + + Use FT_Get_Sfnt_Name_Count to get the total number of available + 'name' table entries, then do a loop until you get the right + platform, encoding, and name ID. + ''' + name = FT_SfntName( ) + error = FT_Get_Sfnt_Name( self._FT_Face, index, byref(name) ) + if error: raise FT_Exception( error ) + return SfntName( name ) + + def get_best_name_string(self, nameID, default_string='', preferred_order=None): + ''' + Retrieve a name string given nameID. Searches available font names + matching nameID and returns the decoded bytes of the best match. + "Best" is defined as a preferred list of platform/encoding/languageIDs + which can be overridden by supplying a preferred_order matching the + scheme of 'sort_order' (see below). + + The routine will attempt to decode the string's bytes to a Python str, when the + platform/encoding[/langID] are known (Windows, Mac, or Unicode platforms). + + If you prefer more control over name string selection and decoding than + this routine provides: + - call self._init_name_string_map() + - use (nameID, platformID, encodingID, languageID) as a key into + the self._name_strings dict + ''' + if not(self._name_strings): + self._init_name_string_map() + + sort_order = preferred_order or ( + (3, 1, 1033), # Microsoft/Windows/US English + (1, 0, 0), # Mac/Roman/English + (0, 6, 0), # Unicode/SMP/* + (0, 4, 0), # Unicode/SMP/* + (0, 3, 0), # Unicode/BMP/* + (0, 2, 0), # Unicode/10646-BMP/* + (0, 1, 0), # Unicode/1.1/* + ) + + # get all keys matching nameID + keys_present = [k for k in self._name_strings.keys() if k[0] == nameID] + + if keys_present: + # sort found keys by sort_order + key_order = {k: v for v, k in enumerate(sort_order)} + keys_present.sort(key=lambda x: key_order.get(x[1:4])) + best_key = keys_present[0] + nsbytes = self._name_strings[best_key] + + if best_key[1:3] == (3, 1) or best_key[1] == 0: + enc = "utf-16-be" + elif best_key[1:4] == (1, 0, 0): + enc = "mac-roman" + else: + enc = "unicode_escape" + + ns = nsbytes.decode(enc) + + else: + ns = default_string + + return ns + + def get_variation_info(self): + ''' + Retrieves variation space information for the current face. + ''' + if version() < (2, 8, 1): + raise NotImplementedError("freetype-py VF support requires FreeType 2.8.1 or later") + + p_amaster = pointer(FT_MM_Var()) + error = FT_Get_MM_Var(self._FT_Face, byref(p_amaster)) + + if error: + raise FT_Exception(error) + + vsi = VariationSpaceInfo(self, p_amaster) + + FT_Done_MM_Var_func(p_amaster) + + return vsi + + def get_var_blend_coords(self): + ''' + Get the current blend coordinates (-1.0..+1.0) + ''' + vsi = self.get_variation_info() + num_coords = len(vsi.axes) + ft_coords = (FT_Fixed * num_coords)() + error = FT_Get_Var_Blend_Coordinates(self._FT_Face, num_coords, byref(ft_coords)) + + if error: + raise FT_Exception(error) + + coords = tuple([ft_coords[ai]/65536.0 for ai in range(num_coords)]) + + return coords + + def set_var_blend_coords(self, coords, reset=False): + ''' + Set blend coords. Using reset=True will set all axes to + their default coordinates. + ''' + if reset: + error = FT_Set_Var_Blend_Coordinates(self._FT_Face, 0, 0) + else: + num_coords = len(coords) + ft_coords = [int(round(c * 65536.0)) for c in coords] + coords_array = (FT_Fixed * num_coords)(*ft_coords) + error = FT_Set_Var_Blend_Coordinates(self._FT_Face, num_coords, byref(coords_array)) + + if error: + raise FT_Exception(error) + + def get_var_design_coords(self): + ''' + Get the current design coordinates + ''' + vsi = self.get_variation_info() + num_coords = len(vsi.axes) + ft_coords = (FT_Fixed * num_coords)() + error = FT_Get_Var_Design_Coordinates(self._FT_Face, num_coords, byref(ft_coords)) + + if error: + raise FT_Exception(error) + + coords = tuple([ft_coords[ai]/65536.0 for ai in range(num_coords)]) + + return coords + + def set_var_design_coords(self, coords, reset=False): + ''' + Set design coords. Using reset=True will set all axes to + their default coordinates. + ''' + if reset: + error = FT_Set_Var_Design_Coordinates(self._FT_Face, 0, 0) + + else: + num_coords = len(coords) + ft_coords = [int(round(c * 65536.0)) for c in coords] + coords_array = (FT_Fixed * num_coords)(*ft_coords) + error = FT_Set_Var_Design_Coordinates(self._FT_Face, num_coords, byref(coords_array)) + + if error: + raise FT_Exception(error) + + def set_var_named_instance(self, instance_name): + ''' + Set instance by name. This will work with any FreeType with variable support + (for our purposes: v2.8.1 or later). If the actual FT_Set_Named_Instance() + function is available (v2.9.1 or later), we use it (which, despite what you might + expect from its name, sets instances by *index*). Otherwise we just use the coords + of the named instance (if found) and call self.set_var_design_coords. + ''' + have_func = freetype.version() >= (2, 9, 1) + vsi = self.get_variation_info() + + for inst_idx, inst in enumerate(vsi.instances, start=1): + if inst.name == instance_name: + if have_func: + error = FT_Set_Named_Instance(self._FT_Face, inst_idx) + else: + error = self.set_var_design_coords(inst.coords) + + if error: + raise FT_Exception(error) + + break + + # named instance not found; do nothing + + def _get_postscript_name( self ): + return FT_Get_Postscript_Name( self._FT_Face ) + postscript_name = property( _get_postscript_name, + doc = '''ASCII PostScript name of face, if available. This only + works with PostScript and TrueType fonts.''') + + def _has_horizontal( self ): + return bool( self.face_flags & FT_FACE_FLAG_HORIZONTAL ) + has_horizontal = property( _has_horizontal, + doc = '''True whenever a face object contains horizontal metrics + (this is true for all font formats though).''') + + def _has_vertical( self ): + return bool( self.face_flags & FT_FACE_FLAG_VERTICAL ) + has_vertical = property( _has_vertical, + doc = '''True whenever a face object contains vertical metrics.''') + + def _has_kerning( self ): + return bool( self.face_flags & FT_FACE_FLAG_KERNING ) + has_kerning = property( _has_kerning, + doc = '''True whenever a face object contains kerning data that can + be accessed with FT_Get_Kerning.''') + + def _is_scalable( self ): + return bool( self.face_flags & FT_FACE_FLAG_SCALABLE ) + is_scalable = property( _is_scalable, + doc = '''true whenever a face object contains a scalable font face + (true for TrueType, Type 1, Type 42, CID, OpenType/CFF, + and PFR font formats.''') + + def _is_sfnt( self ): + return bool( self.face_flags & FT_FACE_FLAG_SFNT ) + is_sfnt = property( _is_sfnt, + doc = '''true whenever a face object contains a font whose format is + based on the SFNT storage scheme. This usually means: TrueType + fonts, OpenType fonts, as well as SFNT-based embedded bitmap + fonts. + + If this macro is true, all functions defined in + FT_SFNT_NAMES_H and FT_TRUETYPE_TABLES_H are available.''') + + def _is_fixed_width( self ): + return bool( self.face_flags & FT_FACE_FLAG_FIXED_WIDTH ) + is_fixed_width = property( _is_fixed_width, + doc = '''True whenever a face object contains a font face that + contains fixed-width (or 'monospace', 'fixed-pitch', + etc.) glyphs.''') + + def _has_fixed_sizes( self ): + return bool( self.face_flags & FT_FACE_FLAG_FIXED_SIZES ) + has_fixed_sizes = property( _has_fixed_sizes, + doc = '''True whenever a face object contains some embedded + bitmaps. See the 'available_sizes' field of the FT_FaceRec + structure.''') + + def _has_glyph_names( self ): + return bool( self.face_flags & FT_FACE_FLAG_GLYPH_NAMES ) + has_glyph_names = property( _has_glyph_names, + doc = '''True whenever a face object contains some glyph names + that can be accessed through FT_Get_Glyph_Name.''') + + def _has_multiple_masters( self ): + return bool( self.face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS ) + has_multiple_masters = property( _has_multiple_masters, + doc = '''True whenever a face object contains some + multiple masters. The functions provided by + FT_MULTIPLE_MASTERS_H are then available to + choose the exact design you want.''') + + def _is_cid_keyed( self ): + return bool( self.face_flags & FT_FACE_FLAG_CID_KEYED ) + is_cid_keyed = property( _is_cid_keyed, + doc = '''True whenever a face object contains a CID-keyed + font. See the discussion of FT_FACE_FLAG_CID_KEYED for + more details. + + If this macro is true, all functions defined in FT_CID_H + are available.''') + + def _is_tricky( self ): + return bool( self.face_flags & FT_FACE_FLAG_TRICKY ) + is_tricky = property( _is_tricky, + doc = '''True whenever a face represents a 'tricky' font. See the + discussion of FT_FACE_FLAG_TRICKY for more details.''') + + + num_faces = property(lambda self: self._FT_Face.contents.num_faces, + doc = '''The number of faces in the font file. Some font formats can + have multiple faces in a font file.''') + + face_index = property(lambda self: self._FT_Face.contents.face_index, + doc = '''The index of the face in the font file. It is set to 0 if + there is only one face in the font file.''') + + face_flags = property(lambda self: self._FT_Face.contents.face_flags, + doc = '''A set of bit flags that give important information about + the face; see FT_FACE_FLAG_XXX for the details.''') + + style_flags = property(lambda self: self._FT_Face.contents.style_flags, + doc = '''A set of bit flags indicating the style of the face; see + FT_STYLE_FLAG_XXX for the details.''') + + num_glyphs = property(lambda self: self._FT_Face.contents.num_glyphs, + doc = '''The number of glyphs in the face. If the face is scalable + and has sbits (see 'num_fixed_sizes'), it is set to the number of + outline glyphs. + + For CID-keyed fonts, this value gives the highest CID used in the + font.''') + + family_name = property(lambda self: self._FT_Face.contents.family_name, + doc = '''The face's family name. This is an ASCII string, usually + in English, which describes the typeface's family (like + 'Times New Roman', 'Bodoni', 'Garamond', etc). This is a + least common denominator used to list fonts. Some formats + (TrueType & OpenType) provide localized and Unicode + versions of this string. Applications should use the + format specific interface to access them. Can be NULL + (e.g., in fonts embedded in a PDF file).''') + + style_name = property(lambda self: self._FT_Face.contents.style_name, + doc = '''The face's style name. This is an ASCII string, usually in + English, which describes the typeface's style (like + 'Italic', 'Bold', 'Condensed', etc). Not all font formats + provide a style name, so this field is optional, and can be + set to NULL. As for 'family_name', some formats provide + localized and Unicode versions of this string. Applications + should use the format specific interface to access them.''') + + num_fixed_sizes = property(lambda self: self._FT_Face.contents.num_fixed_sizes, + doc = '''The number of bitmap strikes in the face. Even if the + face is scalable, there might still be bitmap strikes, + which are called 'sbits' in that case.''') + + def _get_available_sizes( self ): + sizes = [] + n = self.num_fixed_sizes + FT_sizes = self._FT_Face.contents.available_sizes + for i in range(n): + sizes.append( BitmapSize(FT_sizes[i]) ) + return sizes + available_sizes = property(_get_available_sizes, + doc = '''A list of FT_Bitmap_Size for all bitmap strikes in the + face. It is set to NULL if there is no bitmap strike.''') + + num_charmaps = property(lambda self: self._FT_Face.contents.num_charmaps) + def _get_charmaps( self ): + charmaps = [] + n = self._FT_Face.contents.num_charmaps + FT_charmaps = self._FT_Face.contents.charmaps + for i in range(n): + charmaps.append( Charmap(FT_charmaps[i]) ) + return charmaps + charmaps = property(_get_charmaps, + doc = '''A list of the charmaps of the face.''') + + # ('generic', FT_Generic), + + def _get_bbox( self ): + return BBox( self._FT_Face.contents.bbox ) + bbox = property( _get_bbox, + doc = '''The font bounding box. Coordinates are expressed in font units + (see 'units_per_EM'). The box is large enough to contain any + glyph from the font. Thus, 'bbox.yMax' can be seen as the + 'maximal ascender', and 'bbox.yMin' as the 'minimal + descender'. Only relevant for scalable formats. + + Note that the bounding box might be off by (at least) one pixel + for hinted fonts. See FT_Size_Metrics for further discussion.''') + + units_per_EM = property(lambda self: self._FT_Face.contents.units_per_EM, + doc = '''The number of font units per EM square for this + face. This is typically 2048 for TrueType fonts, and 1000 + for Type 1 fonts. Only relevant for scalable formats.''') + + ascender = property(lambda self: self._FT_Face.contents.ascender, + doc = '''The typographic ascender of the face, expressed in font + units. For font formats not having this information, it is + set to 'bbox.yMax'. Only relevant for scalable formats.''') + + descender = property(lambda self: self._FT_Face.contents.descender, + doc = '''The typographic descender of the face, expressed in font + units. For font formats not having this information, it is + set to 'bbox.yMin'. Note that this field is usually + negative. Only relevant for scalable formats.''') + + height = property(lambda self: self._FT_Face.contents.height, + doc = '''The height is the vertical distance between two consecutive + baselines, expressed in font units. It is always positive. Only + relevant for scalable formats.''') + + max_advance_width = property(lambda self: self._FT_Face.contents.max_advance_width, + doc = '''The maximal advance width, in font units, for all + glyphs in this face. This can be used to make word + wrapping computations faster. Only relevant for + scalable formats.''') + + max_advance_height = property(lambda self: self._FT_Face.contents.max_advance_height, + doc = '''The maximal advance height, in font units, for all + glyphs in this face. This is only relevant for + vertical layouts, and is set to 'height' for fonts + that do not provide vertical metrics. Only relevant + for scalable formats.''') + + underline_position = property(lambda self: self._FT_Face.contents.underline_position, + doc = '''The position, in font units, of the underline line + for this face. It is the center of the underlining + stem. Only relevant for scalable formats.''') + + underline_thickness = property(lambda self: self._FT_Face.contents.underline_thickness, + doc = '''The thickness, in font units, of the underline for + this face. Only relevant for scalable formats.''') + + + def _get_glyph( self ): + return GlyphSlot( self._FT_Face.contents.glyph ) + glyph = property( _get_glyph, + doc = '''The face's associated glyph slot(s).''') + + def _get_size( self ): + size = self._FT_Face.contents.size + metrics = size.contents.metrics + return SizeMetrics(metrics) + size = property( _get_size, + doc = '''The current active size for this face.''') + + def _get_charmap( self ): + return Charmap( self._FT_Face.contents.charmap) + charmap = property( _get_charmap, + doc = '''The current active charmap for this face.''') + + + +# ----------------------------------------------------------------------------- +# SfntName wrapper +# ----------------------------------------------------------------------------- +class SfntName( object ): + ''' + SfntName wrapper + + A structure used to model an SFNT 'name' table entry. + ''' + def __init__(self, name): + ''' + Create a new SfntName object. + + :param name : SFNT 'name' table entry. + + ''' + self._FT_SfntName = name + + platform_id = property(lambda self: self._FT_SfntName.platform_id, + doc = '''The platform ID for 'string'.''') + + encoding_id = property(lambda self: self._FT_SfntName.encoding_id, + doc = '''The encoding ID for 'string'.''') + + language_id = property(lambda self: self._FT_SfntName.language_id, + doc = '''The language ID for 'string'.''') + + name_id = property(lambda self: self._FT_SfntName.name_id, + doc = '''An identifier for 'string'.''') + + #string = property(lambda self: self._FT_SfntName.string) + + string_len = property(lambda self: self._FT_SfntName.string_len, + doc = '''The length of 'string' in bytes.''') + + def _get_string(self): + # #s = self._FT_SfntName + s = string_at(self._FT_SfntName.string, self._FT_SfntName.string_len) + return s + # #return s.decode('utf-16be', 'ignore') + # return s.decode('utf-8', 'ignore') + # #n = s.string_len + # #data = [s.string[i] for i in range(n)] + # #return data + string = property(_get_string, + doc = '''The 'name' string. Note that its format differs depending on + the (platform,encoding) pair. It can be a Pascal String, a + UTF-16 one, etc. + + Generally speaking, the string is not zero-terminated. Please + refer to the TrueType specification for details.''') + + + +# ----------------------------------------------------------------------------- +class Stroker( object ): + ''' + FT_Stroker wrapper + + This component generates stroked outlines of a given vectorial glyph. It + also allows you to retrieve the 'outside' and/or the 'inside' borders of + the stroke. + + This can be useful to generate 'bordered' glyph, i.e., glyphs displayed + with a coloured (and anti-aliased) border around their shape. + ''' + + def __init__( self ): + ''' + Create a new Stroker object. + ''' + library = get_handle( ) + stroker = FT_Stroker( ) + error = FT_Stroker_New( library, byref(stroker) ) + if error: raise FT_Exception( error ) + self._FT_Stroker = stroker + + + def __del__( self ): + ''' + Destroy object. + ''' + FT_Stroker_Done( self._FT_Stroker ) + + + def set( self, radius, line_cap, line_join, miter_limit ): + ''' + Reset a stroker object's attributes. + + :param radius: The border radius. + + :param line_cap: The line cap style. + + :param line_join: The line join style. + + :param miter_limit: The miter limit for the FT_STROKER_LINEJOIN_MITER + style, expressed as 16.16 fixed point value. + + **Note**: + + The radius is expressed in the same units as the outline coordinates. + ''' + FT_Stroker_Set( self._FT_Stroker, + radius, line_cap, line_join, miter_limit ) + + + def rewind( self ): + ''' + Reset a stroker object without changing its attributes. You should call + this function before beginning a new series of calls to + FT_Stroker_BeginSubPath or FT_Stroker_EndSubPath. + ''' + FT_Stroker_Rewind( self._FT_Stroker ) + + + def parse_outline( self, outline, opened ): + ''' + A convenience function used to parse a whole outline with the + stroker. The resulting outline(s) can be retrieved later by functions + like FT_Stroker_GetCounts and FT_Stroker_Export. + + :param outline: The source outline. + + :pram opened: A boolean. If 1, the outline is treated as an open path + instead of a closed one. + + **Note**: + + If 'opened' is 0 (the default), the outline is treated as a closed + path, and the stroker generates two distinct 'border' outlines. + + If 'opened' is 1, the outline is processed as an open path, and the + stroker generates a single 'stroke' outline. + + This function calls 'rewind' automatically. + ''' + error = FT_Stroker_ParseOutline( self._FT_Stroker, byref(outline._FT_Outline), opened) + if error: raise FT_Exception( error ) + + + def begin_subpath( self, to, _open ): + ''' + Start a new sub-path in the stroker. + + :param to A pointer to the start vector. + + :param _open: A boolean. If 1, the sub-path is treated as an open one. + + **Note**: + + This function is useful when you need to stroke a path that is not + stored as an 'Outline' object. + ''' + error = FT_Stroker_BeginSubPath( self._FT_Stroker, to, _open ) + if error: raise FT_Exception( error ) + + + def end_subpath( self ): + ''' + Close the current sub-path in the stroker. + + **Note**: + + You should call this function after 'begin_subpath'. If the subpath + was not 'opened', this function 'draws' a single line segment to the + start position when needed. + ''' + error = FT_Stroker_EndSubPath( self._FT_Stroker) + if error: raise FT_Exception( error ) + + + def line_to( self, to ): + ''' + 'Draw' a single line segment in the stroker's current sub-path, from + the last position. + + :param to: A pointer to the destination point. + + **Note**: + + You should call this function between 'begin_subpath' and + 'end_subpath'. + ''' + error = FT_Stroker_LineTo( self._FT_Stroker, to ) + if error: raise FT_Exception( error ) + + + def conic_to( self, control, to ): + ''' + 'Draw' a single quadratic Bezier in the stroker's current sub-path, + from the last position. + + :param control: A pointer to a Bezier control point. + + :param to: A pointer to the destination point. + + **Note**: + + You should call this function between 'begin_subpath' and + 'end_subpath'. + ''' + error = FT_Stroker_ConicTo( self._FT_Stroker, control, to ) + if error: raise FT_Exception( error ) + + + def cubic_to( self, control1, control2, to ): + ''' + 'Draw' a single quadratic Bezier in the stroker's current sub-path, + from the last position. + + :param control1: A pointer to the first Bezier control point. + + :param control2: A pointer to second Bezier control point. + + :param to: A pointer to the destination point. + + **Note**: + + You should call this function between 'begin_subpath' and + 'end_subpath'. + ''' + error = FT_Stroker_CubicTo( self._FT_Stroker, control1, control2, to ) + if error: raise FT_Exception( error ) + + + def get_border_counts( self, border ): + ''' + Call this function once you have finished parsing your paths with the + stroker. It returns the number of points and contours necessary to + export one of the 'border' or 'stroke' outlines generated by the + stroker. + + :param border: The border index. + + :return: number of points, number of contours + ''' + anum_points = FT_UInt() + anum_contours = FT_UInt() + error = FT_Stroker_GetBorderCounts( self._FT_Stroker, border, + byref(anum_points), byref(anum_contours) ) + if error: raise FT_Exception( error ) + return anum_points.value, anum_contours.value + + + def export_border( self , border, outline ): + ''' + Call this function after 'get_border_counts' to export the + corresponding border to your own 'Outline' structure. + + Note that this function appends the border points and contours to your + outline, but does not try to resize its arrays. + + :param border: The border index. + + :param outline: The target outline. + + **Note**: + + Always call this function after get_border_counts to get sure that + there is enough room in your 'Outline' object to receive all new + data. + + When an outline, or a sub-path, is 'closed', the stroker generates two + independent 'border' outlines, named 'left' and 'right' + + When the outline, or a sub-path, is 'opened', the stroker merges the + 'border' outlines with caps. The 'left' border receives all points, + while the 'right' border becomes empty. + + Use the function export instead if you want to retrieve all borders + at once. + ''' + FT_Stroker_ExportBorder( self._FT_Stroker, border, byref(outline._FT_Outline) ) + + + def get_counts( self ): + ''' + Call this function once you have finished parsing your paths with the + stroker. It returns the number of points and contours necessary to + export all points/borders from the stroked outline/path. + + :return: number of points, number of contours + ''' + + anum_points = FT_UInt() + anum_contours = FT_UInt() + error = FT_Stroker_GetCounts( self._FT_Stroker, + byref(anum_points), byref(anum_contours) ) + if error: raise FT_Exception( error ) + return anum_points.value, anum_contours.value + + + def export( self, outline ): + ''' + Call this function after get_border_counts to export all borders to + your own 'Outline' structure. + + Note that this function appends the border points and contours to your + outline, but does not try to resize its arrays. + + :param outline: The target outline. + ''' + FT_Stroker_Export( self._FT_Stroker, byref(outline._FT_Outline) ) + + +# ----------------------------------------------------------------------------- +# Classes related to Variable Font support +# +class VariationAxis(object): + tag = None + coords = tuple() + + def __init__(self, ftvaraxis): + self.tag = unmake_tag(ftvaraxis.tag) + self.name = ftvaraxis.name.decode('ascii') + self.minimum = ftvaraxis.minimum/65536.0 + self.default = ftvaraxis.default/65536.0 + self.maximum = ftvaraxis.maximum/65536.0 + self.strid = ftvaraxis.strid # do we need this? Should be same as 'name'... + + def __repr__(self): + return "".format( + self.tag, self.name, self.minimum, self.default, self.maximum) + +class VariationInstance(object): + def __init__(self, name, psname, coords): + self.name = name + self.psname = psname + self.coords = coords + + def __repr__(self): + return "".format( + self.name, self.coords) + +class VariationSpaceInfo(object): + """ + VF info (axes & instances). + """ + def __init__(self, face, p_ftmmvar): + """ + Build a VariationSpaceInfo object given face (freetype.Face) and + p_ftmmvar (pointer to FT_MM_Var). + """ + ftmv = p_ftmmvar.contents + + axes = [] + for axidx in range(ftmv.num_axis): + axes.append(VariationAxis(ftmv.axis[axidx])) + + self.axes = tuple(axes) + + inst = [] + for instidx in range(ftmv.num_namedstyles): + instinfo = ftmv.namedstyle[instidx] + nid = instinfo.strid + name = face.get_best_name_string(nid) + psid = instinfo.psid + psname = face.get_best_name_string(psid) + coords = [] + for cidx in range(len(self.axes)): + coords.append(instinfo.coords[cidx]/65536.0) + + inst.append(VariationInstance(name, psname, tuple(coords))) + + self.instances = tuple(inst) diff --git a/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/__init__.py b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d8cd6aaf76ebb3a3c9cc2d7ee607826198077a93 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/__init__.py @@ -0,0 +1,12 @@ +import os + + +HERE = os.path.dirname(__file__) + + +def get_hook_dirs(): + return [HERE] + + +def get_test_dirs(): + return [os.path.join(HERE, 'tests')] diff --git a/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..27aa6e9af991d6766ecfd82e816e5da7568962b3 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/__pycache__/hook-freetype.cpython-310.pyc b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/__pycache__/hook-freetype.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..573c81590dd755fd51f668414ebd0c1db63b6e21 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/__pycache__/hook-freetype.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/hook-freetype.py b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/hook-freetype.py new file mode 100644 index 0000000000000000000000000000000000000000..54bfbf1c75484c65d50fc20c50cca28c80957e22 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/hook-freetype.py @@ -0,0 +1,4 @@ +from PyInstaller.utils.hooks import collect_dynamic_libs + + +binaries = collect_dynamic_libs("freetype") diff --git a/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__init__.py b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3899a9c63875bc5726f4399f45e78106798888f7 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__pycache__/conftest.cpython-310.pyc b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__pycache__/conftest.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cba179e1832e904a6095e9981fe35799481303bf Binary files /dev/null and b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__pycache__/conftest.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__pycache__/test_freetype.cpython-310.pyc b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__pycache__/test_freetype.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d6f329dbd3e83d01c9052068715775364f80149 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/__pycache__/test_freetype.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/conftest.py b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..f82c6f73bcaa60fad6c9fef5907682062f3dd2c1 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/conftest.py @@ -0,0 +1 @@ +from PyInstaller.utils.conftest import * diff --git a/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/test_freetype.py b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/test_freetype.py new file mode 100644 index 0000000000000000000000000000000000000000..e3d89bd83899522ccbfa7b1b188e8e3044833488 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/test_freetype.py @@ -0,0 +1,30 @@ +def test_pyi_freetype(pyi_builder): + pyi_builder.test_source( + """ + import sys + import pathlib + + import freetype + + # Ensure that the freetype shared library is bundled with the frozen + # application; otherwise, freetype might be using system-wide library. + + # Check that freetype.FT_Library_filename is an absolute path; + # otherwise, it is likely using basename-only ctypes fallback. + ft_library_file = pathlib.Path(freetype.FT_Library_filename) + print(f"FT library file (original): {ft_library_file}", file=sys.stderr) + assert ft_library_file.is_absolute(), \ + "FT library file is not an absolute path!" + + # Check that fully-resolved freetype.FT_Library_filename is + # anchored in fully-resolved frozen application directory. + app_dir = pathlib.Path(__file__).resolve().parent + print(f"Application directory: {app_dir}", file=sys.stderr) + + ft_library_path = pathlib.Path(ft_library_file).resolve() + print(f"FT library file (resolved): {ft_library_path}", file=sys.stderr) + + assert app_dir in ft_library_path.parents, \ + "FT library is not bundled with frozen application!" + """ + ) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/__init__.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ed2e9e4f77f693cdc030c48abe59ab43260e34de --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/__init__.py @@ -0,0 +1,126 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +''' +Freetype enum types +------------------- + +FT_CURVE_TAGS: An enumeration type for each point on an outline to indicate + whether it describes a point used to control a line segment + or an arc. + +FT_PIXEL_MODES: An enumeration type used to describe the format of pixels in a + given bitmap. Note that additional formats may be added in the + future. + +FT_GLYPH_BBOX_MODES: The mode how the values of FT_Glyph_Get_CBox are returned. + +FT_GLYPH_FORMATS: An enumeration type used to describe the format of a given + glyph image. Note that this version of FreeType only supports + two image formats, even though future font drivers will be + able to register their own format. + +FT_ENCODINGS: An enumeration used to specify character sets supported by + charmaps. Used in the FT_Select_Charmap API function. + +FT_RENDER_MODES: An enumeration type that lists the render modes supported by + FreeType 2. Each mode corresponds to a specific type of + scanline conversion performed on the outline. + +FT_LOAD_TARGETS: A list of values that are used to select a specific hinting + algorithm to use by the hinter. You should OR one of these + values to your 'load_flags' when calling FT_Load_Glyph. + +FT_LOAD_FLAGS: A list of bit-field constants used with FT_Load_Glyph to + indicate what kind of operations to perform during glyph + loading. + +FT_STYLE_FLAGS: A list of bit-flags used to indicate the style of a given + face. These are used in the 'style_flags' field of FT_FaceRec. + +FT_FSTYPES: A list of bit flags that inform client applications of embedding + and subsetting restrictions associated with a font. + +FT_FACE_FLAGS: A list of bit flags used in the 'face_flags' field of the + FT_FaceRec structure. They inform client applications of + properties of the corresponding face. + +FT_OUTLINE_FLAGS: A list of bit-field constants use for the flags in an + outline's 'flags' field. + +FT_OPEN_MODES: A list of bit-field constants used within the 'flags' field of + the FT_Open_Args structure. + +FT_KERNING_MODES: An enumeration used to specify which kerning values to return + in FT_Get_Kerning. + +FT_STROKER_LINEJOINS: These values determine how two joining lines are rendered + in a stroker. + +FT_STROKER_LINECAPS: These values determine how the end of opened sub-paths are + rendered in a stroke. + +FT_STROKER_BORDERS: These values are used to select a given stroke border in + FT_Stroker_GetBorderCounts and FT_Stroker_ExportBorder. + +FT_LCD_FILTERS: A list of values to identify various types of LCD filters. + +TT_PLATFORMS: A list of valid values for the 'platform_id' identifier code in + FT_CharMapRec and FT_SfntName structures. + +TT_APPLE_IDS: A list of valid values for the 'encoding_id' for + TT_PLATFORM_APPLE_UNICODE charmaps and name entries. + +TT_MAC_IDS: A list of valid values for the 'encoding_id' for + TT_PLATFORM_MACINTOSH charmaps and name entries. + +TT_MS_IDS: A list of valid values for the 'encoding_id' for + TT_PLATFORM_MICROSOFT charmaps and name entries. + +TT_ADOBE_IDS: A list of valid values for the 'encoding_id' for + TT_PLATFORM_ADOBE charmaps. This is a FreeType-specific + extension! + +TT_MAC_LANGIDS: Possible values of the language identifier field in the name + records of the TTF `name' table if the `platform' identifier + code is TT_PLATFORM_MACINTOSH. + +TT_MS_LANGIDS: Possible values of the language identifier field in the name + records of the TTF `name' table if the `platform' identifier + code is TT_PLATFORM_MICROSOFT. + +TT_NAME_IDS: Possible values of the `name' identifier field in the name + records of the TTF `name' table. These values are platform + independent. +''' +from freetype.ft_enums.ft_color_root_transform import * +from freetype.ft_enums.ft_curve_tags import * +from freetype.ft_enums.ft_fstypes import * +from freetype.ft_enums.ft_face_flags import * +from freetype.ft_enums.ft_encodings import * +from freetype.ft_enums.ft_glyph_bbox_modes import * +from freetype.ft_enums.ft_glyph_formats import * +from freetype.ft_enums.ft_kerning_modes import * +from freetype.ft_enums.ft_lcd_filters import * +from freetype.ft_enums.ft_load_flags import * +from freetype.ft_enums.ft_load_targets import * +from freetype.ft_enums.ft_open_modes import * +from freetype.ft_enums.ft_outline_flags import * +from freetype.ft_enums.ft_pixel_modes import * +from freetype.ft_enums.ft_render_modes import * +from freetype.ft_enums.ft_stroker_borders import * +from freetype.ft_enums.ft_stroker_linecaps import * +from freetype.ft_enums.ft_stroker_linejoins import * +from freetype.ft_enums.ft_style_flags import * +from freetype.ft_enums.tt_adobe_ids import * +from freetype.ft_enums.tt_apple_ids import * +from freetype.ft_enums.tt_mac_ids import * +from freetype.ft_enums.tt_ms_ids import * +from freetype.ft_enums.tt_ms_langids import * +from freetype.ft_enums.tt_mac_langids import * +from freetype.ft_enums.tt_name_ids import * +from freetype.ft_enums.tt_platforms import * diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_color_root_transform.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_color_root_transform.py new file mode 100644 index 0000000000000000000000000000000000000000..51bf361d22ed8183de9077adf1b1e80452d141c1 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_color_root_transform.py @@ -0,0 +1,6 @@ +FT_Color_Root_Transform = { + 'FT_COLOR_INCLUDE_ROOT_TRANSFORM' : 0, + 'FT_COLOR_NO_ROOT_TRANSFORM' : 1, + 'FT_COLOR_ROOT_TRANSFORM_MAX' : 2, +} +globals().update(FT_Color_Root_Transform) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_encodings.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_encodings.py new file mode 100644 index 0000000000000000000000000000000000000000..566bc375e553aceb7bf7834794d54c40428bd4e9 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_encodings.py @@ -0,0 +1,108 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +An enumeration used to specify character sets supported by charmaps. Used in +the FT_Select_Charmap API function. + +FT_ENCODING_NONE + + The encoding value 0 is reserved. + +FT_ENCODING_UNICODE + + Corresponds to the Unicode character set. This value covers all versions of + the Unicode repertoire, including ASCII and Latin-1. Most fonts include a + Unicode charmap, but not all of them. + + For example, if you want to access Unicode value U+1F028 (and the font + contains it), use value 0x1F028 as the input value for FT_Get_Char_Index. + +FT_ENCODING_MS_SYMBOL + + Corresponds to the Microsoft Symbol encoding, used to encode mathematical + symbols in the 32..255 character code range. For more information, see + 'http://www.ceviz.net/symbol.htm'. + +FT_ENCODING_SJIS + + Corresponds to Japanese SJIS encoding. More info at at + 'http://langsupport.japanreference.com/encoding.shtml'. See note on + multi-byte encodings below. + +FT_ENCODING_PRC + + Corresponds to encoding systems mainly for Simplified Chinese as + used in People's Republic of China (PRC). The encoding layout + is based on GB~2312 and its supersets GBK and GB~18030. + +FT_ENCODING_BIG5 + + Corresponds to an encoding system for Traditional Chinese as used in Taiwan + and Hong Kong. + +FT_ENCODING_WANSUNG + + Corresponds to the Korean encoding system known as Wansung. For more + information see 'http://www.microsoft.com/typography/unicode/949.txt'. + +FT_ENCODING_JOHAB + + The Korean standard character set (KS C 5601-1992), which corresponds to MS + Windows code page 1361. This character set includes all possible Hangeul + character combinations. + +FT_ENCODING_ADOBE_LATIN_1 + + Corresponds to a Latin-1 encoding as defined in a Type 1 PostScript font. It + is limited to 256 character codes. + +FT_ENCODING_ADOBE_STANDARD + + Corresponds to the Adobe Standard encoding, as found in Type 1, CFF, and + OpenType/CFF fonts. It is limited to 256 character codes. + +FT_ENCODING_ADOBE_EXPERT + + Corresponds to the Adobe Expert encoding, as found in Type 1, CFF, and + OpenType/CFF fonts. It is limited to 256 character codes. + +FT_ENCODING_ADOBE_CUSTOM + + Corresponds to a custom encoding, as found in Type 1, CFF, and OpenType/CFF + fonts. It is limited to 256 character codes. + +FT_ENCODING_APPLE_ROMAN + + Corresponds to the 8-bit Apple roman encoding. Many TrueType and OpenType + fonts contain a charmap for this encoding, since older versions of Mac OS are + able to use it. + +FT_ENCODING_OLD_LATIN_2 + + This value is deprecated and was never used nor reported by FreeType. Don't + use or test for it. +""" + +def _FT_ENC_TAG(a,b,c,d): + return ( ord(a) << 24 | ord(b) << 16 | ord(c) << 8 | ord(d) ) + +FT_ENCODINGS = {'FT_ENCODING_NONE' : _FT_ENC_TAG('\0','\0','\0','\0'), + 'FT_ENCODING_MS_SYMBOL' : _FT_ENC_TAG( 's','y','m','b' ), + 'FT_ENCODING_UNICODE' : _FT_ENC_TAG( 'u','n','i','c' ), + 'FT_ENCODING_SJIS' : _FT_ENC_TAG( 's','j','i','s' ), + 'FT_ENCODING_PRC' : _FT_ENC_TAG( 'g','b',' ',' ' ), + 'FT_ENCODING_BIG5' : _FT_ENC_TAG( 'b','i','g','5' ), + 'FT_ENCODING_WANSUNG' : _FT_ENC_TAG( 'w','a','n','s' ), + 'FT_ENCODING_JOHAB' : _FT_ENC_TAG( 'j','o','h','a' ), + 'FT_ENCODING_ADOBE_STANDARD' : _FT_ENC_TAG( 'A','D','O','B' ), + 'FT_ENCODING_ADOBE_EXPERT' : _FT_ENC_TAG( 'A','D','B','E' ), + 'FT_ENCODING_ADOBE_CUSTOM' : _FT_ENC_TAG( 'A','D','B','C' ), + 'FT_ENCODING_ADOBE_LATIN1' : _FT_ENC_TAG( 'l','a','t','1' ), + 'FT_ENCODING_OLD_LATIN2' : _FT_ENC_TAG( 'l','a','t','2' ), + 'FT_ENCODING_APPLE_ROMAN' : _FT_ENC_TAG( 'a','r','m','n' ) } +globals().update(FT_ENCODINGS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_face_flags.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_face_flags.py new file mode 100644 index 0000000000000000000000000000000000000000..75ccf603e6ed8e6e93ad4ce3ba2b66d051bbdc55 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_face_flags.py @@ -0,0 +1,132 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +A list of bit flags used in the 'face_flags' field of the FT_FaceRec +structure. They inform client applications of properties of the corresponding +face. + + +FT_FACE_FLAG_SCALABLE + + Indicates that the face contains outline glyphs. This doesn't prevent bitmap + strikes, i.e., a face can have both this and and FT_FACE_FLAG_FIXED_SIZES + set. + + +FT_FACE_FLAG_FIXED_SIZES + + Indicates that the face contains bitmap strikes. See also the + 'num_fixed_sizes' and 'available_sizes' fields of FT_FaceRec. + + +FT_FACE_FLAG_FIXED_WIDTH + + Indicates that the face contains fixed-width characters (like Courier, + Lucido, MonoType, etc.). + + +FT_FACE_FLAG_SFNT + + Indicates that the face uses the 'sfnt' storage scheme. For now, this means + TrueType and OpenType. + + +FT_FACE_FLAG_HORIZONTAL + + Indicates that the face contains horizontal glyph metrics. This should be set + for all common formats. + + +FT_FACE_FLAG_VERTICAL + + Indicates that the face contains vertical glyph metrics. This is only + available in some formats, not all of them. + + +FT_FACE_FLAG_KERNING + + Indicates that the face contains kerning information. If set, the kerning + distance can be retrieved through the function FT_Get_Kerning. Otherwise the + function always return the vector (0,0). Note that FreeType doesn't handle + kerning data from the 'GPOS' table (as present in some OpenType fonts). + + +FT_FACE_FLAG_MULTIPLE_MASTERS + + Indicates that the font contains multiple masters and is capable of + interpolating between them. See the multiple-masters specific API for + details. + + +FT_FACE_FLAG_GLYPH_NAMES + + Indicates that the font contains glyph names that can be retrieved through + FT_Get_Glyph_Name. Note that some TrueType fonts contain broken glyph name + tables. Use the function FT_Has_PS_Glyph_Names when needed. + + +FT_FACE_FLAG_EXTERNAL_STREAM + + Used internally by FreeType to indicate that a face's stream was provided by + the client application and should not be destroyed when FT_Done_Face is + called. Don't read or test this flag. + + +FT_FACE_FLAG_HINTER + + Set if the font driver has a hinting machine of its own. For example, with + TrueType fonts, it makes sense to use data from the SFNT 'gasp' table only if + the native TrueType hinting engine (with the bytecode interpreter) is + available and active. + + +FT_FACE_FLAG_CID_KEYED + + Set if the font is CID-keyed. In that case, the font is not accessed by glyph + indices but by CID values. For subsetted CID-keyed fonts this has the + consequence that not all index values are a valid argument to + FT_Load_Glyph. Only the CID values for which corresponding glyphs in the + subsetted font exist make FT_Load_Glyph return successfully; in all other + cases you get an 'FT_Err_Invalid_Argument' error. + + Note that CID-keyed fonts which are in an SFNT wrapper don't have this flag + set since the glyphs are accessed in the normal way (using contiguous + indices); the 'CID-ness' isn't visible to the application. + + +FT_FACE_FLAG_TRICKY + + Set if the font is 'tricky', this is, it always needs the font format's + native hinting engine to get a reasonable result. A typical example is the + Chinese font 'mingli.ttf' which uses TrueType bytecode instructions to move + and scale all of its subglyphs. + + It is not possible to autohint such fonts using FT_LOAD_FORCE_AUTOHINT; it + will also ignore FT_LOAD_NO_HINTING. You have to set both FT_LOAD_NO_HINTING + and FT_LOAD_NO_AUTOHINT to really disable hinting; however, you probably + never want this except for demonstration purposes. + + Currently, there are six TrueType fonts in the list of tricky fonts; they are + hard-coded in file 'ttobjs.c'. +""" +FT_FACE_FLAGS = { 'FT_FACE_FLAG_SCALABLE' : 1 << 0, + 'FT_FACE_FLAG_FIXED_SIZES' : 1 << 1, + 'FT_FACE_FLAG_FIXED_WIDTH' : 1 << 2, + 'FT_FACE_FLAG_SFNT' : 1 << 3, + 'FT_FACE_FLAG_HORIZONTAL' : 1 << 4, + 'FT_FACE_FLAG_VERTICAL' : 1 << 5, + 'FT_FACE_FLAG_KERNING' : 1 << 6, + 'FT_FACE_FLAG_FAST_GLYPHS' : 1 << 7, + 'FT_FACE_FLAG_MULTIPLE_MASTERS' : 1 << 8, + 'FT_FACE_FLAG_GLYPH_NAMES' : 1 << 9, + 'FT_FACE_FLAG_EXTERNAL_STREAM' : 1 << 10, + 'FT_FACE_FLAG_HINTER' : 1 << 11, + 'FT_FACE_FLAG_CID_KEYED' : 1 << 12, + 'FT_FACE_FLAG_TRICKY' : 1 << 13 +} +globals().update(FT_FACE_FLAGS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_fstypes.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_fstypes.py new file mode 100644 index 0000000000000000000000000000000000000000..41c0ee59805d4594fd9c4de53850cc3296b54f7e --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_fstypes.py @@ -0,0 +1,64 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +A list of bit flags that inform client applications of embedding and +subsetting restrictions associated with a font. + +FT_FSTYPE_INSTALLABLE_EMBEDDING + + Fonts with no fsType bit set may be embedded and permanently installed on + the remote system by an application. + + +FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING + + Fonts that have only this bit set must not be modified, embedded or exchanged + in any manner without first obtaining permission of the font software + copyright owner. + + +FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING + + If this bit is set, the font may be embedded and temporarily loaded on the + remote system. Documents containing Preview & Print fonts must be opened + 'read-only'; no edits can be applied to the document. + + +FT_FSTYPE_EDITABLE_EMBEDDING + + If this bit is set, the font may be embedded but must only be installed + temporarily on other systems. In contrast to Preview & Print fonts, + documents containing editable fonts may be opened for reading, editing is + permitted, and changes may be saved. + + +FT_FSTYPE_NO_SUBSETTING + + If this bit is set, the font may not be subsetted prior to embedding. + + +FT_FSTYPE_BITMAP_EMBEDDING_ONLY + + If this bit is set, only bitmaps contained in the font may be embedded; no + outline data may be embedded. If there are no bitmaps available in the font, + then the font is unembeddable. +""" + +FT_FSTYPES = {'FT_FSTYPE_INSTALLABLE_EMBEDDING' : 0x0000, + 'FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING' : 0x0002, + 'FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING' : 0x0004, + 'FT_FSTYPE_EDITABLE_EMBEDDING' : 0x0008, + 'FT_FSTYPE_NO_SUBSETTING' : 0x0100, + 'FT_FSTYPE_BITMAP_EMBEDDING_ONLY' : 0x0200,} +globals().update(FT_FSTYPES) +ft_fstype_installable_embedding = FT_FSTYPE_INSTALLABLE_EMBEDDING +ft_fstype_restricted_license_embedding = FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING +ft_fstype_preview_and_print_embedding = FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING +ft_fstype_editable_embedding = FT_FSTYPE_EDITABLE_EMBEDDING +ft_fstype_no_subsetting = FT_FSTYPE_NO_SUBSETTING +ft_fstype_bitmap_embedding_only = FT_FSTYPE_BITMAP_EMBEDDING_ONLY diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_glyph_formats.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_glyph_formats.py new file mode 100644 index 0000000000000000000000000000000000000000..beb67bff171fe3b99ef541198e88f6bcc240a7fa --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_glyph_formats.py @@ -0,0 +1,63 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +An enumeration type used to describe the format of a given glyph image. Note +that this version of FreeType only supports two image formats, even though +future font drivers will be able to register their own format. + +FT_GLYPH_FORMAT_NONE + + The value 0 is reserved. + +FT_GLYPH_FORMAT_COMPOSITE + + The glyph image is a composite of several other images. This format is only + used with FT_LOAD_NO_RECURSE, and is used to report compound glyphs (like + accented characters). + +FT_GLYPH_FORMAT_BITMAP + + The glyph image is a bitmap, and can be described as an FT_Bitmap. You + generally need to access the 'bitmap' field of the FT_GlyphSlotRec structure + to read it. + +FT_GLYPH_FORMAT_OUTLINE + + The glyph image is a vectorial outline made of line segments and Bezier arcs; + it can be described as an FT_Outline; you generally want to access the + 'outline' field of the FT_GlyphSlotRec structure to read it. + +FT_GLYPH_FORMAT_PLOTTER + + The glyph image is a vectorial path with no inside and outside contours. Some + Type 1 fonts, like those in the Hershey family, contain glyphs in this + format. These are described as FT_Outline, but FreeType isn't currently + capable of rendering them correctly. + +FT_GLYPH_FORMAT_SVG + + [Since 2.12] The glyph is represented by an SVG document in the 'SVG~' table. +""" + +def _FT_IMAGE_TAG(a,b,c,d): + return ( ord(a) << 24 | ord(b) << 16 | ord(c) << 8 | ord(d) ) + +FT_GLYPH_FORMATS = { + 'FT_GLYPH_FORMAT_NONE' : _FT_IMAGE_TAG( '\0','\0','\0','\0' ), + 'FT_GLYPH_FORMAT_COMPOSITE' : _FT_IMAGE_TAG( 'c','o','m','p' ), + 'FT_GLYPH_FORMAT_BITMAP' : _FT_IMAGE_TAG( 'b','i','t','s' ), + 'FT_GLYPH_FORMAT_OUTLINE' : _FT_IMAGE_TAG( 'o','u','t','l' ), + 'FT_GLYPH_FORMAT_PLOTTER' : _FT_IMAGE_TAG( 'p','l','o','t' ), + 'FT_GLYPH_FORMAT_SVG' : _FT_IMAGE_TAG( 'S','V','G',' ' )} +globals().update(FT_GLYPH_FORMATS) +ft_glyph_format_none = FT_GLYPH_FORMAT_NONE +ft_glyph_format_composite = FT_GLYPH_FORMAT_COMPOSITE +ft_glyph_format_bitmap = FT_GLYPH_FORMAT_BITMAP +ft_glyph_format_outline = FT_GLYPH_FORMAT_OUTLINE +ft_glyph_format_plotter = FT_GLYPH_FORMAT_PLOTTER +ft_glyph_format_svg = FT_GLYPH_FORMAT_SVG diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_lcd_filters.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_lcd_filters.py new file mode 100644 index 0000000000000000000000000000000000000000..53c6f0888b72d993742f9db1cf73a230ae4d8790 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_lcd_filters.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- + +""" +A list of values to identify various types of LCD filters. + + +FT_LCD_FILTER_NONE + + Do not perform filtering. When used with subpixel rendering, this results in + sometimes severe color fringes. + + +FT_LCD_FILTER_DEFAULT + + The default filter reduces color fringes considerably, at the cost of a + slight blurriness in the output. + + +FT_LCD_FILTER_LIGHT + + The light filter is a variant that produces less blurriness at the cost of + slightly more color fringes than the default one. It might be better, + depending on taste, your monitor, or your personal vision. + + +FT_LCD_FILTER_LEGACY + + This filter corresponds to the original libXft color filter. It provides high + contrast output but can exhibit really bad color fringes if glyphs are not + extremely well hinted to the pixel grid. In other words, it only works well + if the TrueType bytecode interpreter is enabled and high-quality hinted fonts + are used. + + This filter is only provided for comparison purposes, and might be disabled + or stay unsupported in the future. +""" + +FT_LCD_FILTERS = {'FT_LCD_FILTER_NONE' : 0, + 'FT_LCD_FILTER_DEFAULT' : 1, + 'FT_LCD_FILTER_LIGHT' : 2, + 'FT_LCD_FILTER_LEGACY' : 16} +globals().update(FT_LCD_FILTERS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_open_modes.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_open_modes.py new file mode 100644 index 0000000000000000000000000000000000000000..a2b1c279db2a4edf43e63e11019a022fb8c9e4c5 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_open_modes.py @@ -0,0 +1,42 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +A list of bit-field constants used within the 'flags' field of the +FT_Open_Args structure. + + +FT_OPEN_MEMORY + + This is a memory-based stream. + + +FT_OPEN_STREAM + + Copy the stream from the 'stream' field. + + +FT_OPEN_PATHNAME + + Create a new input stream from a C path name. + + +FT_OPEN_DRIVER + + Use the 'driver' field. + + +FT_OPEN_PARAMS + + Use the 'num_params' and 'params' fields. +""" +FT_OPEN_MODES = {'FT_OPEN_MEMORY': 0x1, + 'FT_OPEN_STREAM': 0x2, + 'FT_OPEN_PATHNAME': 0x4, + 'FT_OPEN_DRIVER': 0x8, + 'FT_OPEN_PARAMS': 0x10 } +globals().update(FT_OPEN_MODES) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_outline_flags.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_outline_flags.py new file mode 100644 index 0000000000000000000000000000000000000000..d7ff0fab2b7d9689b3a58c35abd034793d6e02b0 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_outline_flags.py @@ -0,0 +1,84 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +A list of bit-field constants use for the flags in an outline's 'flags' +field. + + +FT_OUTLINE_NONE + + Value 0 is reserved. + + +FT_OUTLINE_OWNER + + If set, this flag indicates that the outline's field arrays (i.e., 'points', + 'flags', and 'contours') are 'owned' by the outline object, and should thus + be freed when it is destroyed. + + +FT_OUTLINE_EVEN_ODD_FILL + + By default, outlines are filled using the non-zero winding rule. If set to 1, + the outline will be filled using the even-odd fill rule (only works with the + smooth rasterizer). + + +FT_OUTLINE_REVERSE_FILL + + By default, outside contours of an outline are oriented in clock-wise + direction, as defined in the TrueType specification. This flag is set if the + outline uses the opposite direction (typically for Type 1 fonts). This flag + is ignored by the scan converter. + + +FT_OUTLINE_IGNORE_DROPOUTS + + By default, the scan converter will try to detect drop-outs in an outline and + correct the glyph bitmap to ensure consistent shape continuity. If set, this + flag hints the scan-line converter to ignore such cases. See below for more + information. + + +FT_OUTLINE_SMART_DROPOUTS + + Select smart dropout control. If unset, use simple dropout control. Ignored + if FT_OUTLINE_IGNORE_DROPOUTS is set. See below for more information. + + +FT_OUTLINE_INCLUDE_STUBS + + If set, turn pixels on for 'stubs', otherwise exclude them. Ignored if + FT_OUTLINE_IGNORE_DROPOUTS is set. See below for more information. + + +FT_OUTLINE_HIGH_PRECISION + + This flag indicates that the scan-line converter should try to convert this + outline to bitmaps with the highest possible quality. It is typically set for + small character sizes. Note that this is only a hint that might be completely + ignored by a given scan-converter. + + +FT_OUTLINE_SINGLE_PASS + + This flag is set to force a given scan-converter to only use a single pass + over the outline to render a bitmap glyph image. Normally, it is set for very + large character sizes. It is only a hint that might be completely ignored by + a given scan-converter. +""" +FT_OUTLINE_FLAGS = { 'FT_OUTLINE_NONE' : 0x0, + 'FT_OUTLINE_OWNER' : 0x1, + 'FT_OUTLINE_EVEN_ODD_FILL' : 0x2, + 'FT_OUTLINE_REVERSE_FILL' : 0x4, + 'FT_OUTLINE_IGNORE_DROPOUTS' : 0x8, + 'FT_OUTLINE_SMART_DROPOUTS' : 0x10, + 'FT_OUTLINE_INCLUDE_STUBS' : 0x20, + 'FT_OUTLINE_HIGH_PRECISION' : 0x100, + 'FT_OUTLINE_SINGLE_PASS' : 0x200 } +globals().update(FT_OUTLINE_FLAGS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_pixel_modes.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_pixel_modes.py new file mode 100644 index 0000000000000000000000000000000000000000..3841a7bdb9acf8a0a138b9a9554d5e9d819814bb --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_pixel_modes.py @@ -0,0 +1,85 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +An enumeration type that lists the render modes supported by FreeType 2. Each +mode corresponds to a specific type of scanline conversion performed on the +outline. + + +FT_PIXEL_MODE_NONE + + Value 0 is reserved. + + +FT_PIXEL_MODE_MONO + + A monochrome bitmap, using 1 bit per pixel. Note that pixels are stored in + most-significant order (MSB), which means that the left-most pixel in a byte + has value 128. + + +FT_PIXEL_MODE_GRAY + + An 8-bit bitmap, generally used to represent anti-aliased glyph images. Each + pixel is stored in one byte. Note that the number of 'gray' levels is stored + in the 'num_grays' field of the FT_Bitmap structure (it generally is 256). + + +FT_PIXEL_MODE_GRAY2 + + A 2-bit per pixel bitmap, used to represent embedded anti-aliased bitmaps in + font files according to the OpenType specification. We haven't found a single + font using this format, however. + + +FT_PIXEL_MODE_GRAY4 + + A 4-bit per pixel bitmap, representing embedded anti-aliased bitmaps in font + files according to the OpenType specification. We haven't found a single font + using this format, however. + + +FT_PIXEL_MODE_LCD + + An 8-bit bitmap, representing RGB or BGR decimated glyph images used for + display on LCD displays; the bitmap is three times wider than the original + glyph image. See also FT_RENDER_MODE_LCD. + + +FT_PIXEL_MODE_LCD_V + + An 8-bit bitmap, representing RGB or BGR decimated glyph images used for + display on rotated LCD displays; the bitmap is three times taller than the + original glyph image. See also FT_RENDER_MODE_LCD_V. + + +FT_PIXEL_MODE_BGRA + [Since 2.5] An image with four 8-bit channels per pixel, + representing a color image (such as emoticons) with alpha channel. + For each pixel, the format is BGRA, which means, the blue channel + comes first in memory. The color channels are pre-multiplied and in + the sRGB colorspace. For example, full red at half-translucent + opacity will be represented as '00,00,80,80', not '00,00,FF,80'. + See also @FT_LOAD_COLOR. +""" + +FT_PIXEL_MODES = {'FT_PIXEL_MODE_NONE' : 0, + 'FT_PIXEL_MODE_MONO' : 1, + 'FT_PIXEL_MODE_GRAY' : 2, + 'FT_PIXEL_MODE_GRAY2': 3, + 'FT_PIXEL_MODE_GRAY4': 4, + 'FT_PIXEL_MODE_LCD' : 5, + 'FT_PIXEL_MODE_LCD_V': 6, + 'FT_PIXEL_MODE_BGRA' : 7, + 'FT_PIXEL_MODE_MAX' : 8} +globals().update(FT_PIXEL_MODES) +ft_pixel_mode_none = FT_PIXEL_MODE_NONE +ft_pixel_mode_mono = FT_PIXEL_MODE_MONO +ft_pixel_mode_grays = FT_PIXEL_MODE_GRAY +ft_pixel_mode_pal2 = FT_PIXEL_MODE_GRAY2 +ft_pixel_mode_pal4 = FT_PIXEL_MODE_GRAY4 diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_render_modes.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_render_modes.py new file mode 100644 index 0000000000000000000000000000000000000000..77806008b777a45e4c9c097561a65cd72959663e --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_render_modes.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +An enumeration type that lists the render modes supported by FreeType 2. Each +mode corresponds to a specific type of scanline conversion performed on the +outline. + +For bitmap fonts and embedded bitmaps the 'bitmap->pixel_mode' field in the +FT_GlyphSlotRec structure gives the format of the returned bitmap. + +All modes except FT_RENDER_MODE_MONO use 256 levels of opacity. + + +FT_RENDER_MODE_NORMAL + + This is the default render mode; it corresponds to 8-bit anti-aliased + bitmaps. + + +FT_RENDER_MODE_LIGHT + + This is equivalent to FT_RENDER_MODE_NORMAL. It is only defined as a separate + value because render modes are also used indirectly to define hinting + algorithm selectors. See FT_LOAD_TARGET_XXX for details. + + +FT_RENDER_MODE_MONO + + This mode corresponds to 1-bit bitmaps (with 2 levels of opacity). + + +FT_RENDER_MODE_LCD + + This mode corresponds to horizontal RGB and BGR sub-pixel displays like LCD + screens. It produces 8-bit bitmaps that are 3 times the width of the original + glyph outline in pixels, and which use the FT_PIXEL_MODE_LCD mode. + + +FT_RENDER_MODE_LCD_V + + This mode corresponds to vertical RGB and BGR sub-pixel displays (like PDA + screens, rotated LCD displays, etc.). It produces 8-bit bitmaps that are 3 + times the height of the original glyph outline in pixels and use the + FT_PIXEL_MODE_LCD_V mode. + +FT_RENDER_MODE_SDF + + This mode corresponds to 8-bit, single-channel signed distance field (SDF) + bitmaps. Each pixel in the SDF grid is the value from the pixel's position to + the nearest glyph's outline. The distances are calculated from the center of + the pixel and are positive if they are filled by the outline (i.e., inside + the outline) and negative otherwise. Check the note below on how to convert + the output values to usable data. +""" +FT_RENDER_MODES = { 'FT_RENDER_MODE_NORMAL' : 0, + 'FT_RENDER_MODE_LIGHT' : 1, + 'FT_RENDER_MODE_MONO' : 2, + 'FT_RENDER_MODE_LCD' : 3, + 'FT_RENDER_MODE_LCD_V' : 4, + 'FT_RENDER_MODE_SDF' : 5 } +globals().update(FT_RENDER_MODES) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_stroker_borders.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_stroker_borders.py new file mode 100644 index 0000000000000000000000000000000000000000..6e6f8cdcd0ea2771dfeb50b971762ffe54323a7a --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_stroker_borders.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +These values are used to select a given stroke border in +FT_Stroker_GetBorderCounts and FT_Stroker_ExportBorder. + + +FT_STROKER_BORDER_LEFT + + Select the left border, relative to the drawing direction. + + +FT_STROKER_BORDER_RIGHT + + Select the right border, relative to the drawing direction. + + +Note + + Applications are generally interested in the 'inside' and 'outside' + borders. However, there is no direct mapping between these and the 'left' and + 'right' ones, since this really depends on the glyph's drawing orientation, + which varies between font formats. + + You can however use FT_Outline_GetInsideBorder and + FT_Outline_GetOutsideBorder to get these. +""" +FT_STROKER_BORDERS = { 'FT_STROKER_BORDER_LEFT' : 0, + 'FT_STROKER_BORDER_RIGHT' : 1} +globals().update(FT_STROKER_BORDERS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_stroker_linecaps.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_stroker_linecaps.py new file mode 100644 index 0000000000000000000000000000000000000000..1e540ecd3bf5edb65bc4ebfa276d1b5c7630fa8e --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_stroker_linecaps.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +These values determine how the end of opened sub-paths are rendered in a +stroke. + + +FT_STROKER_LINECAP_BUTT + + The end of lines is rendered as a full stop on the last point itself. + + +FT_STROKER_LINECAP_ROUND + + The end of lines is rendered as a half-circle around the last point. + + +FT_STROKER_LINECAP_SQUARE + + The end of lines is rendered as a square around the last point. +""" + +FT_STROKER_LINECAPS = { 'FT_STROKER_LINECAP_BUTT' : 0, + 'FT_STROKER_LINECAP_ROUND' : 1, + 'FT_STROKER_LINECAP_SQUARE' : 2} +globals().update(FT_STROKER_LINECAPS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_style_flags.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_style_flags.py new file mode 100644 index 0000000000000000000000000000000000000000..2db3ce401c3187a2e8f7936b1211f7a9ead739c7 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/ft_style_flags.py @@ -0,0 +1,24 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +A list of bit-flags used to indicate the style of a given face. These are +used in the 'style_flags' field of FT_FaceRec. + + +FT_STYLE_FLAG_ITALIC + + Indicates that a given face style is italic or oblique. + + +FT_STYLE_FLAG_BOLD + + Indicates that a given face is bold. +""" +FT_STYLE_FLAGS = {'FT_STYLE_FLAG_ITALIC' : 1, + 'FT_STYLE_FLAG_BOLD' : 2 } +globals().update(FT_STYLE_FLAGS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_adobe_ids.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_adobe_ids.py new file mode 100644 index 0000000000000000000000000000000000000000..3b7ea52856f6d38d998faa89e6e6e86b134be728 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_adobe_ids.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +A list of valid values for the 'encoding_id' for TT_PLATFORM_ADOBE +charmaps. This is a FreeType-specific extension! + +TT_ADOBE_ID_STANDARD + + Adobe standard encoding. + + +TT_ADOBE_ID_EXPERT + + Adobe expert encoding. + + +TT_ADOBE_ID_CUSTOM + + Adobe custom encoding. + + +TT_ADOBE_ID_LATIN_1 + + Adobe Latin 1 encoding. +""" + +TT_ADOBE_IDS = { + 'TT_ADOBE_ID_STANDARD' : 0, + 'TT_ADOBE_ID_EXPERT' : 1, + 'TT_ADOBE_ID_CUSTOM' : 2, + 'TT_ADOBE_ID_LATIN_1' : 3 } +globals().update(TT_ADOBE_IDS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_apple_ids.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_apple_ids.py new file mode 100644 index 0000000000000000000000000000000000000000..3e0f3b79640defa2e229f5365f9ef0671862e108 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_apple_ids.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +A list of valid values for the 'encoding_id' for TT_PLATFORM_APPLE_UNICODE +charmaps and name entries. + + +TT_APPLE_ID_DEFAULT + + Unicode version 1.0. + + +TT_APPLE_ID_UNICODE_1_1 + + Unicode 1.1; specifies Hangul characters starting at U+34xx. + + +TT_APPLE_ID_ISO_10646 + + Deprecated (identical to preceding). + + +TT_APPLE_ID_UNICODE_2_0 + + Unicode 2.0 and beyond (UTF-16 BMP only). + + +TT_APPLE_ID_UNICODE_32 + + Unicode 3.1 and beyond, using UTF-32. + + +TT_APPLE_ID_VARIANT_SELECTOR + + From Adobe, not Apple. Not a normal cmap. Specifies variations on a real + cmap. +""" +TT_APPLE_IDS = { + 'TT_APPLE_ID_DEFAULT' : 0, + 'TT_APPLE_ID_UNICODE_1_1' : 1, + 'TT_APPLE_ID_ISO_10646' : 2, + 'TT_APPLE_ID_UNICODE_2_0' : 3, + 'TT_APPLE_ID_UNICODE_32' : 4, + 'TT_APPLE_ID_VARIANT_SELECTOR' : 5 } +globals().update(TT_APPLE_IDS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_mac_langids.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_mac_langids.py new file mode 100644 index 0000000000000000000000000000000000000000..59eeaabd07b4e05af3cbcd9924bec589e0464012 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_mac_langids.py @@ -0,0 +1,373 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +Possible values of the language identifier field in the name records of the +TTF 'name' table if the 'platform' identifier code is TT_PLATFORM_MACINTOSH. + +TT_MAC_LANGID_LATIN + +TT_MAC_LANGID_MALAY_ARABIC_SCRIPT + +TT_MAC_LANGID_HINDI + +TT_MAC_LANGID_CATALAN + +TT_MAC_LANGID_MARATHI + +TT_MAC_LANGID_ICELANDIC + +TT_MAC_LANGID_ARABIC + +TT_MAC_LANGID_SWAHILI + +TT_MAC_LANGID_KHMER + +TT_MAC_LANGID_UKRAINIAN + +TT_MAC_LANGID_FINNISH + +TT_MAC_LANGID_POLISH + +TT_MAC_LANGID_NEPALI + +TT_MAC_LANGID_UZBEK + +TT_MAC_LANGID_TELUGU + +TT_MAC_LANGID_MALTESE + +TT_MAC_LANGID_AFRIKAANS + +TT_MAC_LANGID_CHEWA + +TT_MAC_LANGID_BASQUE + +TT_MAC_LANGID_CZECH + +TT_MAC_LANGID_ROMANIAN + +TT_MAC_LANGID_QUECHUA + +TT_MAC_LANGID_TAGALOG + +TT_MAC_LANGID_HUNGARIAN + +TT_MAC_LANGID_AZERBAIJANI_CYRILLIC_SCRIPT + +TT_MAC_LANGID_TONGAN + +TT_MAC_LANGID_SUNDANESE + +TT_MAC_LANGID_JAPANESE + +TT_MAC_LANGID_MONGOLIAN + +TT_MAC_LANGID_ALBANIAN + +TT_MAC_LANGID_NORWEGIAN + +TT_MAC_LANGID_SLOVAK + +TT_MAC_LANGID_MALAGASY + +TT_MAC_LANGID_DZONGKHA + +TT_MAC_LANGID_DUTCH + +TT_MAC_LANGID_MALAY_ROMAN_SCRIPT + +TT_MAC_LANGID_SERBIAN + +TT_MAC_LANGID_GERMAN + +TT_MAC_LANGID_SOMALI + +TT_MAC_LANGID_KOREAN + +TT_MAC_LANGID_MONGOLIAN_MONGOLIAN_SCRIPT + +TT_MAC_LANGID_CROATIAN + +TT_MAC_LANGID_TURKISH + +TT_MAC_LANGID_MOLDAVIAN + +TT_MAC_LANGID_LAO + +TT_MAC_LANGID_ORIYA + +TT_MAC_LANGID_BRETON + +TT_MAC_LANGID_PASHTO + +TT_MAC_LANGID_GUARANI + +TT_MAC_LANGID_HEBREW + +TT_MAC_LANGID_SLOVENIAN + +TT_MAC_LANGID_ESTONIAN + +TT_MAC_LANGID_RUNDI + +TT_MAC_LANGID_URDU + +TT_MAC_LANGID_CHINESE_TRADITIONAL + +TT_MAC_LANGID_TATAR + +TT_MAC_LANGID_CHINESE_SIMPLIFIED + +TT_MAC_LANGID_AZERBAIJANI_ARABIC_SCRIPT + +TT_MAC_LANGID_SANSKRIT + +TT_MAC_LANGID_KURDISH + +TT_MAC_LANGID_FAEROESE + +TT_MAC_LANGID_MONGOLIAN_CYRILLIC_SCRIPT + +TT_MAC_LANGID_TIGRINYA + +TT_MAC_LANGID_THAI + +TT_MAC_LANGID_DANISH + +TT_MAC_LANGID_KAZAKH + +TT_MAC_LANGID_YIDDISH + +TT_MAC_LANGID_ESPERANTO + +TT_MAC_LANGID_LITHUANIAN + +TT_MAC_LANGID_FARSI + +TT_MAC_LANGID_LETTISH + +TT_MAC_LANGID_VIETNAMESE + +TT_MAC_LANGID_PORTUGUESE + +TT_MAC_LANGID_IRISH + +TT_MAC_LANGID_WELSH + +TT_MAC_LANGID_PUNJABI + +TT_MAC_LANGID_GREEK + +TT_MAC_LANGID_INUKTITUT + +TT_MAC_LANGID_FRENCH + +TT_MAC_LANGID_GREEK_POLYTONIC + +TT_MAC_LANGID_AZERBAIJANI + +TT_MAC_LANGID_JAVANESE + +TT_MAC_LANGID_SWEDISH + +TT_MAC_LANGID_UIGHUR + +TT_MAC_LANGID_BENGALI + +TT_MAC_LANGID_RUANDA + +TT_MAC_LANGID_SINDHI + +TT_MAC_LANGID_TIBETAN + +TT_MAC_LANGID_ENGLISH + +TT_MAC_LANGID_SAAMISK + +TT_MAC_LANGID_INDONESIAN + +TT_MAC_LANGID_MANX_GAELIC + +TT_MAC_LANGID_BYELORUSSIAN + +TT_MAC_LANGID_BULGARIAN + +TT_MAC_LANGID_GEORGIAN + +TT_MAC_LANGID_AZERBAIJANI_ROMAN_SCRIPT + +TT_MAC_LANGID_ITALIAN + +TT_MAC_LANGID_SCOTTISH_GAELIC + +TT_MAC_LANGID_ARMENIAN + +TT_MAC_LANGID_GALLA + +TT_MAC_LANGID_MACEDONIAN + +TT_MAC_LANGID_IRISH_GAELIC + +TT_MAC_LANGID_KIRGHIZ + +TT_MAC_LANGID_TAMIL + +TT_MAC_LANGID_SPANISH + +TT_MAC_LANGID_BURMESE + +TT_MAC_LANGID_KANNADA + +TT_MAC_LANGID_GALICIAN + +TT_MAC_LANGID_FLEMISH + +TT_MAC_LANGID_TAJIKI + +TT_MAC_LANGID_ASSAMESE + +TT_MAC_LANGID_SINHALESE + +TT_MAC_LANGID_GREELANDIC + +TT_MAC_LANGID_AMHARIC + +TT_MAC_LANGID_KASHMIRI + +TT_MAC_LANGID_AYMARA + +TT_MAC_LANGID_GUJARATI + +TT_MAC_LANGID_RUSSIAN + +TT_MAC_LANGID_TURKMEN + +TT_MAC_LANGID_MALAYALAM +""" +TT_MAC_LANGIDS = { + 'TT_MAC_LANGID_ENGLISH' : 0, + 'TT_MAC_LANGID_FRENCH' : 1, + 'TT_MAC_LANGID_GERMAN' : 2, + 'TT_MAC_LANGID_ITALIAN' : 3, + 'TT_MAC_LANGID_DUTCH' : 4, + 'TT_MAC_LANGID_SWEDISH' : 5, + 'TT_MAC_LANGID_SPANISH' : 6, + 'TT_MAC_LANGID_DANISH' : 7, + 'TT_MAC_LANGID_PORTUGUESE' : 8, + 'TT_MAC_LANGID_NORWEGIAN' : 9, + 'TT_MAC_LANGID_HEBREW' : 10, + 'TT_MAC_LANGID_JAPANESE' : 11, + 'TT_MAC_LANGID_ARABIC' : 12, + 'TT_MAC_LANGID_FINNISH' : 13, + 'TT_MAC_LANGID_GREEK' : 14, + 'TT_MAC_LANGID_ICELANDIC' : 15, + 'TT_MAC_LANGID_MALTESE' : 16, + 'TT_MAC_LANGID_TURKISH' : 17, + 'TT_MAC_LANGID_CROATIAN' : 18, + 'TT_MAC_LANGID_CHINESE_TRADITIONAL' : 19, + 'TT_MAC_LANGID_URDU' : 20, + 'TT_MAC_LANGID_HINDI' : 21, + 'TT_MAC_LANGID_THAI' : 22, + 'TT_MAC_LANGID_KOREAN' : 23, + 'TT_MAC_LANGID_LITHUANIAN' : 24, + 'TT_MAC_LANGID_POLISH' : 25, + 'TT_MAC_LANGID_HUNGARIAN' : 26, + 'TT_MAC_LANGID_ESTONIAN' : 27, + 'TT_MAC_LANGID_LETTISH' : 28, + 'TT_MAC_LANGID_SAAMISK' : 29, + 'TT_MAC_LANGID_FAEROESE' : 30, + 'TT_MAC_LANGID_FARSI' : 31, + 'TT_MAC_LANGID_RUSSIAN' : 32, + 'TT_MAC_LANGID_CHINESE_SIMPLIFIED' : 33, + 'TT_MAC_LANGID_FLEMISH' : 34, + 'TT_MAC_LANGID_IRISH' : 35, + 'TT_MAC_LANGID_ALBANIAN' : 36, + 'TT_MAC_LANGID_ROMANIAN' : 37, + 'TT_MAC_LANGID_CZECH' : 38, + 'TT_MAC_LANGID_SLOVAK' : 39, + 'TT_MAC_LANGID_SLOVENIAN' : 40, + 'TT_MAC_LANGID_YIDDISH' : 41, + 'TT_MAC_LANGID_SERBIAN' : 42, + 'TT_MAC_LANGID_MACEDONIAN' : 43, + 'TT_MAC_LANGID_BULGARIAN' : 44, + 'TT_MAC_LANGID_UKRAINIAN' : 45, + 'TT_MAC_LANGID_BYELORUSSIAN' : 46, + 'TT_MAC_LANGID_UZBEK' : 47, + 'TT_MAC_LANGID_KAZAKH' : 48, + 'TT_MAC_LANGID_AZERBAIJANI' : 49, + 'TT_MAC_LANGID_AZERBAIJANI_CYRILLIC_SCRIPT': 49, + 'TT_MAC_LANGID_AZERBAIJANI_ARABIC_SCRIPT' : 50, + 'TT_MAC_LANGID_ARMENIAN' : 51, + 'TT_MAC_LANGID_GEORGIAN' : 52, + 'TT_MAC_LANGID_MOLDAVIAN' : 53, + 'TT_MAC_LANGID_KIRGHIZ' : 54, + 'TT_MAC_LANGID_TAJIKI' : 55, + 'TT_MAC_LANGID_TURKMEN' : 56, + 'TT_MAC_LANGID_MONGOLIAN' : 57, + 'TT_MAC_LANGID_MONGOLIAN_MONGOLIAN_SCRIPT' : 57, + 'TT_MAC_LANGID_MONGOLIAN_CYRILLIC_SCRIPT' : 58, + 'TT_MAC_LANGID_PASHTO' : 59, + 'TT_MAC_LANGID_KURDISH' : 60, + 'TT_MAC_LANGID_KASHMIRI' : 61, + 'TT_MAC_LANGID_SINDHI' : 62, + 'TT_MAC_LANGID_TIBETAN' : 63, + 'TT_MAC_LANGID_NEPALI' : 64, + 'TT_MAC_LANGID_SANSKRIT' : 65, + 'TT_MAC_LANGID_MARATHI' : 66, + 'TT_MAC_LANGID_BENGALI' : 67, + 'TT_MAC_LANGID_ASSAMESE' : 68, + 'TT_MAC_LANGID_GUJARATI' : 69, + 'TT_MAC_LANGID_PUNJABI' : 70, + 'TT_MAC_LANGID_ORIYA' : 71, + 'TT_MAC_LANGID_MALAYALAM' : 72, + 'TT_MAC_LANGID_KANNADA' : 73, + 'TT_MAC_LANGID_TAMIL' : 74, + 'TT_MAC_LANGID_TELUGU' : 75, + 'TT_MAC_LANGID_SINHALESE' : 76, + 'TT_MAC_LANGID_BURMESE' : 77, + 'TT_MAC_LANGID_KHMER' : 78, + 'TT_MAC_LANGID_LAO' : 79, + 'TT_MAC_LANGID_VIETNAMESE' : 80, + 'TT_MAC_LANGID_INDONESIAN' : 81, + 'TT_MAC_LANGID_TAGALOG' : 82, + 'TT_MAC_LANGID_MALAY_ROMAN_SCRIPT' : 83, + 'TT_MAC_LANGID_MALAY_ARABIC_SCRIPT' : 84, + 'TT_MAC_LANGID_AMHARIC' : 85, + 'TT_MAC_LANGID_TIGRINYA' : 86, + 'TT_MAC_LANGID_GALLA' : 87, + 'TT_MAC_LANGID_SOMALI' : 88, + 'TT_MAC_LANGID_SWAHILI' : 89, + 'TT_MAC_LANGID_RUANDA' : 90, + 'TT_MAC_LANGID_RUNDI' : 91, + 'TT_MAC_LANGID_CHEWA' : 92, + 'TT_MAC_LANGID_MALAGASY' : 93, + 'TT_MAC_LANGID_ESPERANTO' : 94, + 'TT_MAC_LANGID_WELSH' : 128, + 'TT_MAC_LANGID_BASQUE' : 129, + 'TT_MAC_LANGID_CATALAN' : 130, + 'TT_MAC_LANGID_LATIN' : 131, + 'TT_MAC_LANGID_QUECHUA' : 132, + 'TT_MAC_LANGID_GUARANI' : 133, + 'TT_MAC_LANGID_AYMARA' : 134, + 'TT_MAC_LANGID_TATAR' : 135, + 'TT_MAC_LANGID_UIGHUR' : 136, + 'TT_MAC_LANGID_DZONGKHA' : 137, + 'TT_MAC_LANGID_JAVANESE' : 138, + 'TT_MAC_LANGID_SUNDANESE' : 139, + 'TT_MAC_LANGID_GALICIAN' : 140, + 'TT_MAC_LANGID_AFRIKAANS' : 141, + 'TT_MAC_LANGID_BRETON' : 142, + 'TT_MAC_LANGID_INUKTITUT' : 143, + 'TT_MAC_LANGID_SCOTTISH_GAELIC' : 144, + 'TT_MAC_LANGID_MANX_GAELIC' : 145, + 'TT_MAC_LANGID_IRISH_GAELIC' : 146, + 'TT_MAC_LANGID_TONGAN' : 147, + 'TT_MAC_LANGID_GREEK_POLYTONIC' : 148, + 'TT_MAC_LANGID_GREELANDIC' : 149, + 'TT_MAC_LANGID_AZERBAIJANI_ROMAN_SCRIPT' : 150 } +globals().update(TT_MAC_LANGIDS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_ms_ids.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_ms_ids.py new file mode 100644 index 0000000000000000000000000000000000000000..fa8daf71cd441c9c9a8c326aa1e6a7b8df775a0c --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_ms_ids.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +A list of valid values for the 'encoding_id' for TT_PLATFORM_MICROSOFT +charmaps and name entries. + + +TT_MS_ID_SYMBOL_CS + + Corresponds to Microsoft symbol encoding. See FT_ENCODING_MS_SYMBOL. + + +TT_MS_ID_UNICODE_CS + + Corresponds to a Microsoft WGL4 charmap, matching Unicode. See + FT_ENCODING_UNICODE. + + +TT_MS_ID_SJIS + + Corresponds to SJIS Japanese encoding. See FT_ENCODING_SJIS. + + +TT_MS_ID_PRC + + Chinese encodings as used in the People's Republic of China (PRC). + This means the encodings GB~2312 and its supersets GBK and + GB~18030. See FT_ENCODING_PRC. + + +TT_MS_ID_BIG_5 + + Corresponds to Traditional Chinese as used in Taiwan and Hong Kong. See + FT_ENCODING_BIG5. + + +TT_MS_ID_WANSUNG + + Corresponds to Korean Wansung encoding. See FT_ENCODING_WANSUNG. + +TT_MS_ID_JOHAB + + Corresponds to Johab encoding. See FT_ENCODING_JOHAB. + + +TT_MS_ID_UCS_4 + + Corresponds to UCS-4 or UTF-32 charmaps. This has been added to the OpenType + specification version 1.4 (mid-2001.) +""" + +TT_MS_IDS = { + 'TT_MS_ID_SYMBOL_CS' : 0, + 'TT_MS_ID_UNICODE_CS' : 1, + 'TT_MS_ID_SJIS' : 2, + 'TT_MS_ID_PRC' : 3, + 'TT_MS_ID_BIG_5' : 4, + 'TT_MS_ID_WANSUNG' : 5, + 'TT_MS_ID_JOHAB' : 6, + 'TT_MS_ID_UCS_4' : 10 } +globals().update(TT_MS_IDS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_ms_langids.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_ms_langids.py new file mode 100644 index 0000000000000000000000000000000000000000..a85b0fea97dd1b61d7c7a3c4927a3d75e9ea93d1 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_ms_langids.py @@ -0,0 +1,749 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +Possible values of the language identifier field in the name records of the +TTF 'name' table if the 'platform' identifier code is TT_PLATFORM_MICROSOFT. + +TT_MS_LANGID_SANSKRIT_INDIA + +TT_MS_LANGID_ENGLISH_UNITED_KINGDOM + +TT_MS_LANGID_ENGLISH_BELIZE + +TT_MS_LANGID_ARABIC_LEBANON + +TT_MS_LANGID_MOLDAVIAN_MOLDAVIA + +TT_MS_LANGID_TURKISH_TURKEY + +TT_MS_LANGID_WELSH_WALES + +TT_MS_LANGID_GERMAN_AUSTRIA + +TT_MS_LANGID_DUTCH_BELGIUM + +TT_MS_LANGID_YI_CHINA + +TT_MS_LANGID_QUECHUA_ECUADOR + +TT_MS_LANGID_SPANISH_EL_SALVADOR + +TT_MS_LANGID_SWAHILI_KENYA + +TT_MS_LANGID_QUECHUA_BOLIVIA + +TT_MS_LANGID_SLOVENE_SLOVENIA + +TT_MS_LANGID_ORIYA_INDIA + +TT_MS_LANGID_FARSI_IRAN + +TT_MS_LANGID_ENGLISH_CANADA + +TT_MS_LANGID_NEPALI_NEPAL + +TT_MS_LANGID_DHIVEHI_MALDIVES + +TT_MS_LANGID_GERMAN_LIECHTENSTEI + +TT_MS_LANGID_TAMIL_INDIA + +TT_MS_LANGID_ARABIC_UAE + +TT_MS_LANGID_JAPANESE_JAPAN + +TT_MS_LANGID_TAMAZIGHT_MOROCCO + +TT_MS_LANGID_FRENCH_FRANCE + +TT_MS_LANGID_CHINESE_MACAU + +TT_MS_LANGID_VIETNAMESE_VIET_NAM + +TT_MS_LANGID_HEBREW_ISRAEL + +TT_MS_LANGID_SAMI_NORTHERN_SWEDEN + +TT_MS_LANGID_PUNJABI_ARABIC_PAKISTAN + +TT_MS_LANGID_SWEDISH_SWEDEN + +TT_MS_LANGID_FRENCH_REUNION + +TT_MS_LANGID_ARABIC_BAHRAIN + +TT_MS_LANGID_ENGLISH_INDIA + +TT_MS_LANGID_NEPALI_INDIA + +TT_MS_LANGID_THAI_THAILAND + +TT_MS_LANGID_ENGLISH_GENERAL + +TT_MS_LANGID_SAMI_LULE_NORWAY + +TT_MS_LANGID_ARABIC_OMAN + +TT_MS_LANGID_SPANISH_HONDURAS + +TT_MS_LANGID_ENGLISH_JAMAICA + +TT_MS_LANGID_ESTONIAN_ESTONIA + +TT_MS_LANGID_FRISIAN_NETHERLANDS + +TT_MS_LANGID_LATIN + +TT_MS_LANGID_ENGLISH_INDONESIA + +TT_MS_LANGID_ENGLISH_IRELAND + +TT_MS_LANGID_TIBETAN_CHINA + +TT_MS_LANGID_PUNJABI_INDIA + +TT_MS_LANGID_FRENCH_MALI + +TT_MS_LANGID_GERMAN_LUXEMBOURG + +TT_MS_LANGID_SUTU_SOUTH_AFRICA + +TT_MS_LANGID_FRENCH_CAMEROON + +TT_MS_LANGID_FRENCH_CONGO + +TT_MS_LANGID_CLASSIC_LITHUANIAN_LITHUANIA + +TT_MS_LANGID_MALAYALAM_INDIA + +TT_MS_LANGID_SAMI_SOUTHERN_SWEDEN + +TT_MS_LANGID_CHEROKEE_UNITED_STATES + +TT_MS_LANGID_SPANISH_GUATEMALA + +TT_MS_LANGID_CZECH_CZECH_REPUBLIC + +TT_MS_LANGID_MANIPURI_INDIA + +TT_MS_LANGID_ENGLISH_AUSTRALIA + +TT_MS_LANGID_SPANISH_DOMINICAN_REPUBLIC + +TT_MS_LANGID_ARABIC_LIBYA + +TT_MS_LANGID_FRENCH_WEST_INDIES + +TT_MS_LANGID_ENGLISH_TRINIDAD + +TT_MS_LANGID_ARABIC_QATAR + +TT_MS_LANGID_SPANISH_COLOMBIA + +TT_MS_LANGID_GUARANI_PARAGUAY + +TT_MS_LANGID_EDO_NIGERIA + +TT_MS_LANGID_SEPEDI_SOUTH_AFRICA + +TT_MS_LANGID_ENGLISH_HONG_KONG + +TT_MS_LANGID_KOREAN_EXTENDED_WANSUNG_KOREA + +TT_MS_LANGID_TATAR_TATARSTAN + +TT_MS_LANGID_PASHTO_AFGHANISTAN + +TT_MS_LANGID_KASHMIRI_PAKISTAN + +TT_MS_LANGID_GALICIAN_SPAIN + +TT_MS_LANGID_TAJIK_TAJIKISTAN + +TT_MS_LANGID_SAMI_INARI_FINLAND + +TT_MS_LANGID_KASHMIRI_SASIA + +TT_MS_LANGID_SPANISH_ARGENTINA + +TT_MS_LANGID_SAMI_SOUTHERN_NORWAY + +TT_MS_LANGID_CROATIAN_CROATIA + +TT_MS_LANGID_GUJARATI_INDIA + +TT_MS_LANGID_TIBETAN_BHUTAN + +TT_MS_LANGID_TIGRIGNA_ETHIOPIA + +TT_MS_LANGID_FINNISH_FINLAND + +TT_MS_LANGID_ENGLISH_UNITED_STATES + +TT_MS_LANGID_ITALIAN_SWITZERLAND + +TT_MS_LANGID_ARABIC_EGYPT + +TT_MS_LANGID_SPANISH_LATIN_AMERICA + +TT_MS_LANGID_LITHUANIAN_LITHUANIA + +TT_MS_LANGID_ARABIC_ALGERIA + +TT_MS_LANGID_MALAY_MALAYSIA + +TT_MS_LANGID_ARABIC_GENERAL + +TT_MS_LANGID_CHINESE_PRC + +TT_MS_LANGID_BENGALI_BANGLADESH + +TT_MS_LANGID_SPANISH_PERU + +TT_MS_LANGID_SPANISH_SPAIN_INTERNATIONAL_SORT + +TT_MS_LANGID_DIVEHI_MALDIVES + +TT_MS_LANGID_LATVIAN_LATVIA + +TT_MS_LANGID_TURKMEN_TURKMENISTAN + +TT_MS_LANGID_XHOSA_SOUTH_AFRICA + +TT_MS_LANGID_KHMER_CAMBODIA + +TT_MS_LANGID_NORWEGIAN_NORWAY_NYNORSK + +TT_MS_LANGID_ARABIC_MOROCCO + +TT_MS_LANGID_FRENCH_SENEGAL + +TT_MS_LANGID_YORUBA_NIGERIA + +TT_MS_LANGID_CATALAN_SPAIN + +TT_MS_LANGID_AFRIKAANS_SOUTH_AFRICA + +TT_MS_LANGID_ZULU_SOUTH_AFRICA + +TT_MS_LANGID_SPANISH_URUGUAY + +TT_MS_LANGID_SPANISH_ECUADOR + +TT_MS_LANGID_BOSNIAN_BOSNIA_HERZEGOVINA + +TT_MS_LANGID_CHINESE_GENERAL + +TT_MS_LANGID_SPANISH_PARAGUAY + +TT_MS_LANGID_HINDI_INDIA + +TT_MS_LANGID_FRENCH_LUXEMBOURG + +TT_MS_LANGID_TSWANA_SOUTH_AFRICA + +TT_MS_LANGID_HUNGARIAN_HUNGARY + +TT_MS_LANGID_CROATIAN_BOSNIA_HERZEGOVINA + +TT_MS_LANGID_ENGLISH_SINGAPORE + +TT_MS_LANGID_MALTESE_MALTA + +TT_MS_LANGID_SAMI_NORTHERN_FINLAND + +TT_MS_LANGID_FRENCH_CANADA + +TT_MS_LANGID_SAMI_LULE_SWEDEN + +TT_MS_LANGID_KANURI_NIGERIA + +TT_MS_LANGID_IRISH_GAELIC_IRELAND + +TT_MS_LANGID_ARABIC_SAUDI_ARABIA + +TT_MS_LANGID_FRENCH_HAITI + +TT_MS_LANGID_SPANISH_PUERTO_RICO + +TT_MS_LANGID_BURMESE_MYANMAR + +TT_MS_LANGID_POLISH_POLAND + +TT_MS_LANGID_PORTUGUESE_PORTUGAL + +TT_MS_LANGID_ENGLISH_CARIBBEAN + +TT_MS_LANGID_KIRGHIZ_KIRGHIZ_REPUBLIC + +TT_MS_LANGID_ICELANDIC_ICELAND + +TT_MS_LANGID_BENGALI_INDIA + +TT_MS_LANGID_HAUSA_NIGERIA + +TT_MS_LANGID_BASQUE_SPAIN + +TT_MS_LANGID_UIGHUR_CHINA + +TT_MS_LANGID_ENGLISH_MALAYSIA + +TT_MS_LANGID_FRENCH_MONACO + +TT_MS_LANGID_SPANISH_BOLIVIA + +TT_MS_LANGID_SORBIAN_GERMANY + +TT_MS_LANGID_SINDHI_INDIA + +TT_MS_LANGID_CHINESE_SINGAPORE + +TT_MS_LANGID_FRENCH_COTE_D_IVOIRE + +TT_MS_LANGID_SPANISH_SPAIN_TRADITIONAL_SORT + +TT_MS_LANGID_SERBIAN_SERBIA_CYRILLIC + +TT_MS_LANGID_SAMI_SKOLT_FINLAND + +TT_MS_LANGID_SERBIAN_BOSNIA_HERZ_CYRILLIC + +TT_MS_LANGID_MALAY_BRUNEI_DARUSSALAM + +TT_MS_LANGID_ARABIC_JORDAN + +TT_MS_LANGID_MONGOLIAN_MONGOLIA_MONGOLIAN + +TT_MS_LANGID_SERBIAN_SERBIA_LATIN + +TT_MS_LANGID_RUSSIAN_RUSSIA + +TT_MS_LANGID_ROMANIAN_ROMANIA + +TT_MS_LANGID_FRENCH_NORTH_AFRICA + +TT_MS_LANGID_MONGOLIAN_MONGOLIA + +TT_MS_LANGID_TSONGA_SOUTH_AFRICA + +TT_MS_LANGID_SOMALI_SOMALIA + +TT_MS_LANGID_SAAMI_LAPONIA + +TT_MS_LANGID_SPANISH_COSTA_RICA + +TT_MS_LANGID_ARABIC_SYRIA + +TT_MS_LANGID_SPANISH_PANAMA + +TT_MS_LANGID_PAPIAMENTU_NETHERLANDS_ANTILLES + +TT_MS_LANGID_ASSAMESE_INDIA + +TT_MS_LANGID_SCOTTISH_GAELIC_UNITED_KINGDOM + +TT_MS_LANGID_DUTCH_NETHERLANDS + +TT_MS_LANGID_SINDHI_PAKISTAN + +TT_MS_LANGID_MACEDONIAN_MACEDONIA + +TT_MS_LANGID_KAZAK_KAZAKSTAN + +TT_MS_LANGID_AZERI_AZERBAIJAN_LATIN + +TT_MS_LANGID_BELARUSIAN_BELARUS + +TT_MS_LANGID_FRENCH_MOROCCO + +TT_MS_LANGID_SERBIAN_BOSNIA_HERZ_LATIN + +TT_MS_LANGID_ALBANIAN_ALBANIA + +TT_MS_LANGID_SINHALESE_SRI_LANKA + +TT_MS_LANGID_SPANISH_MEXICO + +TT_MS_LANGID_ENGLISH_ZIMBABWE + +TT_MS_LANGID_OROMO_ETHIOPIA + +TT_MS_LANGID_INDONESIAN_INDONESIA + +TT_MS_LANGID_SAMI_NORTHERN_NORWAY + +TT_MS_LANGID_UZBEK_UZBEKISTAN_LATIN + +TT_MS_LANGID_SLOVAK_SLOVAKIA + +TT_MS_LANGID_KASHMIRI_INDIA + +TT_MS_LANGID_GERMAN_SWITZERLAND + +TT_MS_LANGID_URDU_INDIA + +TT_MS_LANGID_FAEROESE_FAEROE_ISLANDS + +TT_MS_LANGID_SYRIAC_SYRIA + +TT_MS_LANGID_SPANISH_CHILE + +TT_MS_LANGID_FILIPINO_PHILIPPINES + +TT_MS_LANGID_ARABIC_YEMEN + +TT_MS_LANGID_KONKANI_INDIA + +TT_MS_LANGID_AMHARIC_ETHIOPIA + +TT_MS_LANGID_ENGLISH_NEW_ZEALAND + +TT_MS_LANGID_RHAETO_ROMANIC_SWITZERLAND + +TT_MS_LANGID_ARABIC_TUNISIA + +TT_MS_LANGID_SOTHO_SOUTHERN_SOUTH_AFRICA + +TT_MS_LANGID_QUECHUA_PERU + +TT_MS_LANGID_DANISH_DENMARK + +TT_MS_LANGID_ENGLISH_PHILIPPINES + +TT_MS_LANGID_SPANISH_NICARAGUA + +TT_MS_LANGID_INUKTITUT_CANADA + +TT_MS_LANGID_UKRAINIAN_UKRAINE + +TT_MS_LANGID_NORWEGIAN_NORWAY_BOKMAL + +TT_MS_LANGID_UZBEK_UZBEKISTAN_CYRILLIC + +TT_MS_LANGID_FRENCH_BELGIUM + +TT_MS_LANGID_ENGLISH_SOUTH_AFRICA + +TT_MS_LANGID_HAWAIIAN_UNITED_STATES + +TT_MS_LANGID_ARABIC_IRAQ + +TT_MS_LANGID_KANNADA_INDIA + +TT_MS_LANGID_DZONGHKA_BHUTAN + +TT_MS_LANGID_CHINESE_TAIWAN + +TT_MS_LANGID_SPANISH_UNITED_STATES + +TT_MS_LANGID_ARMENIAN_ARMENIA + +TT_MS_LANGID_LAO_LAOS + +TT_MS_LANGID_TIGRIGNA_ERYTREA + +TT_MS_LANGID_MARATHI_INDIA + +TT_MS_LANGID_ARABIC_KUWAIT + +TT_MS_LANGID_TAMAZIGHT_MOROCCO_LATIN + +TT_MS_LANGID_PORTUGUESE_BRAZIL + +TT_MS_LANGID_TIGRIGNA_ERYTHREA + +TT_MS_LANGID_GREEK_GREECE + +TT_MS_LANGID_URDU_PAKISTAN + +TT_MS_LANGID_KIRGHIZ_KIRGHIZSTAN + +TT_MS_LANGID_YIDDISH_GERMANY + +TT_MS_LANGID_GERMAN_GERMANY + +TT_MS_LANGID_TELUGU_INDIA + +TT_MS_LANGID_AZERI_AZERBAIJAN_CYRILLIC + +TT_MS_LANGID_KOREAN_JOHAB_KOREA + +TT_MS_LANGID_ITALIAN_ITALY + +TT_MS_LANGID_MAORI_NEW_ZEALAND + +TT_MS_LANGID_SPANISH_VENEZUELA + +TT_MS_LANGID_IGBO_NIGERIA + +TT_MS_LANGID_IBIBIO_NIGERIA + +TT_MS_LANGID_CHINESE_HONG_KONG + +TT_MS_LANGID_FRENCH_SWITZERLAND + +TT_MS_LANGID_BULGARIAN_BULGARIA + +TT_MS_LANGID_FULFULDE_NIGERIA + +TT_MS_LANGID_RUSSIAN_MOLDAVIA + +TT_MS_LANGID_VENDA_SOUTH_AFRICA + +TT_MS_LANGID_GEORGIAN_GEORGIA + +TT_MS_LANGID_SWEDISH_FINLAND +""" + +TT_MS_LANGIDS = { + 'TT_MS_LANGID_ARABIC_GENERAL' : 0x0001, + 'TT_MS_LANGID_ARABIC_SAUDI_ARABIA' : 0x0401, + 'TT_MS_LANGID_ARABIC_IRAQ' : 0x0801, + 'TT_MS_LANGID_ARABIC_EGYPT' : 0x0c01, + 'TT_MS_LANGID_ARABIC_LIBYA' : 0x1001, + 'TT_MS_LANGID_ARABIC_ALGERIA' : 0x1401, + 'TT_MS_LANGID_ARABIC_MOROCCO' : 0x1801, + 'TT_MS_LANGID_ARABIC_TUNISIA' : 0x1c01, + 'TT_MS_LANGID_ARABIC_OMAN' : 0x2001, + 'TT_MS_LANGID_ARABIC_YEMEN' : 0x2401, + 'TT_MS_LANGID_ARABIC_SYRIA' : 0x2801, + 'TT_MS_LANGID_ARABIC_JORDAN' : 0x2c01, + 'TT_MS_LANGID_ARABIC_LEBANON' : 0x3001, + 'TT_MS_LANGID_ARABIC_KUWAIT' : 0x3401, + 'TT_MS_LANGID_ARABIC_UAE' : 0x3801, + 'TT_MS_LANGID_ARABIC_BAHRAIN' : 0x3c01, + 'TT_MS_LANGID_ARABIC_QATAR' : 0x4001, + 'TT_MS_LANGID_BULGARIAN_BULGARIA' : 0x0402, + 'TT_MS_LANGID_CATALAN_SPAIN' : 0x0403, + 'TT_MS_LANGID_CHINESE_GENERAL' : 0x0004, + 'TT_MS_LANGID_CHINESE_TAIWAN' : 0x0404, + 'TT_MS_LANGID_CHINESE_PRC' : 0x0804, + 'TT_MS_LANGID_CHINESE_HONG_KONG' : 0x0c04, + 'TT_MS_LANGID_CHINESE_SINGAPORE' : 0x1004, + 'TT_MS_LANGID_CHINESE_MACAU' : 0x1404, + 'TT_MS_LANGID_CZECH_CZECH_REPUBLIC' : 0x0405, + 'TT_MS_LANGID_DANISH_DENMARK' : 0x0406, + 'TT_MS_LANGID_GERMAN_GERMANY' : 0x0407, + 'TT_MS_LANGID_GERMAN_SWITZERLAND' : 0x0807, + 'TT_MS_LANGID_GERMAN_AUSTRIA' : 0x0c07, + 'TT_MS_LANGID_GERMAN_LUXEMBOURG' : 0x1007, + 'TT_MS_LANGID_GERMAN_LIECHTENSTEI' : 0x1407, + 'TT_MS_LANGID_GREEK_GREECE' : 0x0408, + 'TT_MS_LANGID_ENGLISH_GENERAL' : 0x0009, + 'TT_MS_LANGID_ENGLISH_UNITED_STATES' : 0x0409, + 'TT_MS_LANGID_ENGLISH_UNITED_KINGDOM' : 0x0809, + 'TT_MS_LANGID_ENGLISH_AUSTRALIA' : 0x0c09, + 'TT_MS_LANGID_ENGLISH_CANADA' : 0x1009, + 'TT_MS_LANGID_ENGLISH_NEW_ZEALAND' : 0x1409, + 'TT_MS_LANGID_ENGLISH_IRELAND' : 0x1809, + 'TT_MS_LANGID_ENGLISH_SOUTH_AFRICA' : 0x1c09, + 'TT_MS_LANGID_ENGLISH_JAMAICA' : 0x2009, + 'TT_MS_LANGID_ENGLISH_CARIBBEAN' : 0x2409, + 'TT_MS_LANGID_ENGLISH_BELIZE' : 0x2809, + 'TT_MS_LANGID_ENGLISH_TRINIDAD' : 0x2c09, + 'TT_MS_LANGID_ENGLISH_ZIMBABWE' : 0x3009, + 'TT_MS_LANGID_ENGLISH_PHILIPPINES' : 0x3409, + 'TT_MS_LANGID_ENGLISH_INDONESIA' : 0x3809, + 'TT_MS_LANGID_ENGLISH_HONG_KONG' : 0x3c09, + 'TT_MS_LANGID_ENGLISH_INDIA' : 0x4009, + 'TT_MS_LANGID_ENGLISH_MALAYSIA' : 0x4409, + 'TT_MS_LANGID_ENGLISH_SINGAPORE' : 0x4809, + 'TT_MS_LANGID_SPANISH_SPAIN_TRADITIONAL_SORT' : 0x040a, + 'TT_MS_LANGID_SPANISH_MEXICO' : 0x080a, + 'TT_MS_LANGID_SPANISH_SPAIN_INTERNATIONAL_SORT' : 0x0c0a, + 'TT_MS_LANGID_SPANISH_GUATEMALA' : 0x100a, + 'TT_MS_LANGID_SPANISH_COSTA_RICA' : 0x140a, + 'TT_MS_LANGID_SPANISH_PANAMA' : 0x180a, + 'TT_MS_LANGID_SPANISH_DOMINICAN_REPUBLIC' : 0x1c0a, + 'TT_MS_LANGID_SPANISH_VENEZUELA' : 0x200a, + 'TT_MS_LANGID_SPANISH_COLOMBIA' : 0x240a, + 'TT_MS_LANGID_SPANISH_PERU' : 0x280a, + 'TT_MS_LANGID_SPANISH_ARGENTINA' : 0x2c0a, + 'TT_MS_LANGID_SPANISH_ECUADOR' : 0x300a, + 'TT_MS_LANGID_SPANISH_CHILE' : 0x340a, + 'TT_MS_LANGID_SPANISH_URUGUAY' : 0x380a, + 'TT_MS_LANGID_SPANISH_PARAGUAY' : 0x3c0a, + 'TT_MS_LANGID_SPANISH_BOLIVIA' : 0x400a, + 'TT_MS_LANGID_SPANISH_EL_SALVADOR' : 0x440a, + 'TT_MS_LANGID_SPANISH_HONDURAS' : 0x480a, + 'TT_MS_LANGID_SPANISH_NICARAGUA' : 0x4c0a, + 'TT_MS_LANGID_SPANISH_PUERTO_RICO' : 0x500a, + 'TT_MS_LANGID_SPANISH_UNITED_STATES' : 0x540a, + 'TT_MS_LANGID_SPANISH_LATIN_AMERICA' : 0xE40a, + 'TT_MS_LANGID_FINNISH_FINLAND' : 0x040b, + 'TT_MS_LANGID_FRENCH_FRANCE' : 0x040c, + 'TT_MS_LANGID_FRENCH_BELGIUM' : 0x080c, + 'TT_MS_LANGID_FRENCH_CANADA' : 0x0c0c, + 'TT_MS_LANGID_FRENCH_SWITZERLAND' : 0x100c, + 'TT_MS_LANGID_FRENCH_LUXEMBOURG' : 0x140c, + 'TT_MS_LANGID_FRENCH_MONACO' : 0x180c, + 'TT_MS_LANGID_FRENCH_WEST_INDIES' : 0x1c0c, + 'TT_MS_LANGID_FRENCH_REUNION' : 0x200c, + 'TT_MS_LANGID_FRENCH_CONGO' : 0x240c, + 'TT_MS_LANGID_FRENCH_SENEGAL' : 0x280c, + 'TT_MS_LANGID_FRENCH_CAMEROON' : 0x2c0c, + 'TT_MS_LANGID_FRENCH_COTE_D_IVOIRE' : 0x300c, + 'TT_MS_LANGID_FRENCH_MALI' : 0x340c, + 'TT_MS_LANGID_FRENCH_MOROCCO' : 0x380c, + 'TT_MS_LANGID_FRENCH_HAITI' : 0x3c0c, + 'TT_MS_LANGID_FRENCH_NORTH_AFRICA' : 0xE40c, + 'TT_MS_LANGID_HEBREW_ISRAEL' : 0x040d, + 'TT_MS_LANGID_HUNGARIAN_HUNGARY' : 0x040e, + 'TT_MS_LANGID_ICELANDIC_ICELAND' : 0x040f, + 'TT_MS_LANGID_ITALIAN_ITALY' : 0x0410, + 'TT_MS_LANGID_ITALIAN_SWITZERLAND' : 0x0810, + 'TT_MS_LANGID_JAPANESE_JAPAN' : 0x0411, + 'TT_MS_LANGID_KOREAN_EXTENDED_WANSUNG_KOREA' : 0x0412, + 'TT_MS_LANGID_KOREAN_JOHAB_KOREA' : 0x0812, + 'TT_MS_LANGID_DUTCH_NETHERLANDS' : 0x0413, + 'TT_MS_LANGID_DUTCH_BELGIUM' : 0x0813, + 'TT_MS_LANGID_NORWEGIAN_NORWAY_BOKMAL' : 0x0414, + 'TT_MS_LANGID_NORWEGIAN_NORWAY_NYNORSK' : 0x0814, + 'TT_MS_LANGID_POLISH_POLAND' : 0x0415, + 'TT_MS_LANGID_PORTUGUESE_BRAZIL' : 0x0416, + 'TT_MS_LANGID_PORTUGUESE_PORTUGAL' : 0x0816, + 'TT_MS_LANGID_RHAETO_ROMANIC_SWITZERLAND' : 0x0417, + 'TT_MS_LANGID_ROMANIAN_ROMANIA' : 0x0418, + 'TT_MS_LANGID_MOLDAVIAN_MOLDAVIA' : 0x0818, + 'TT_MS_LANGID_RUSSIAN_RUSSIA' : 0x0419, + 'TT_MS_LANGID_RUSSIAN_MOLDAVIA' : 0x0819, + 'TT_MS_LANGID_CROATIAN_CROATIA' : 0x041a, + 'TT_MS_LANGID_SERBIAN_SERBIA_LATIN' : 0x081a, + 'TT_MS_LANGID_SERBIAN_SERBIA_CYRILLIC' : 0x0c1a, + 'TT_MS_LANGID_CROATIAN_BOSNIA_HERZEGOVINA' : 0x101a, + 'TT_MS_LANGID_BOSNIAN_BOSNIA_HERZEGOVINA' : 0x141a, + 'TT_MS_LANGID_SERBIAN_BOSNIA_HERZ_LATIN' : 0x181a, + 'TT_MS_LANGID_SERBIAN_BOSNIA_HERZ_CYRILLIC' : 0x181a, + 'TT_MS_LANGID_SLOVAK_SLOVAKIA' : 0x041b, + 'TT_MS_LANGID_ALBANIAN_ALBANIA' : 0x041c, + 'TT_MS_LANGID_SWEDISH_SWEDEN' : 0x041d, + 'TT_MS_LANGID_SWEDISH_FINLAND' : 0x081d, + 'TT_MS_LANGID_THAI_THAILAND' : 0x041e, + 'TT_MS_LANGID_TURKISH_TURKEY' : 0x041f, + 'TT_MS_LANGID_URDU_PAKISTAN' : 0x0420, + 'TT_MS_LANGID_URDU_INDIA' : 0x0820, + 'TT_MS_LANGID_INDONESIAN_INDONESIA' : 0x0421, + 'TT_MS_LANGID_UKRAINIAN_UKRAINE' : 0x0422, + 'TT_MS_LANGID_BELARUSIAN_BELARUS' : 0x0423, + 'TT_MS_LANGID_SLOVENE_SLOVENIA' : 0x0424, + 'TT_MS_LANGID_ESTONIAN_ESTONIA' : 0x0425, + 'TT_MS_LANGID_LATVIAN_LATVIA' : 0x0426, + 'TT_MS_LANGID_LITHUANIAN_LITHUANIA' : 0x0427, + 'TT_MS_LANGID_CLASSIC_LITHUANIAN_LITHUANIA' : 0x0827, + 'TT_MS_LANGID_TAJIK_TAJIKISTAN' : 0x0428, + 'TT_MS_LANGID_FARSI_IRAN' : 0x0429, + 'TT_MS_LANGID_VIETNAMESE_VIET_NAM' : 0x042a, + 'TT_MS_LANGID_ARMENIAN_ARMENIA' : 0x042b, + 'TT_MS_LANGID_AZERI_AZERBAIJAN_LATIN' : 0x042c, + 'TT_MS_LANGID_AZERI_AZERBAIJAN_CYRILLIC' : 0x082c, + 'TT_MS_LANGID_BASQUE_SPAIN' : 0x042d, + 'TT_MS_LANGID_SORBIAN_GERMANY' : 0x042e, + 'TT_MS_LANGID_MACEDONIAN_MACEDONIA' : 0x042f, + 'TT_MS_LANGID_SUTU_SOUTH_AFRICA' : 0x0430, + 'TT_MS_LANGID_TSONGA_SOUTH_AFRICA' : 0x0431, + 'TT_MS_LANGID_TSWANA_SOUTH_AFRICA' : 0x0432, + 'TT_MS_LANGID_VENDA_SOUTH_AFRICA' : 0x0433, + 'TT_MS_LANGID_XHOSA_SOUTH_AFRICA' : 0x0434, + 'TT_MS_LANGID_ZULU_SOUTH_AFRICA' : 0x0435, + 'TT_MS_LANGID_AFRIKAANS_SOUTH_AFRICA' : 0x0436, + 'TT_MS_LANGID_GEORGIAN_GEORGIA' : 0x0437, + 'TT_MS_LANGID_FAEROESE_FAEROE_ISLANDS' : 0x0438, + 'TT_MS_LANGID_HINDI_INDIA' : 0x0439, + 'TT_MS_LANGID_MALTESE_MALTA' : 0x043a, + 'TT_MS_LANGID_SAMI_NORTHERN_NORWAY' : 0x043b, + 'TT_MS_LANGID_SAMI_NORTHERN_SWEDEN' : 0x083b, + 'TT_MS_LANGID_SAMI_NORTHERN_FINLAND' : 0x0C3b, + 'TT_MS_LANGID_SAMI_LULE_NORWAY' : 0x103b, + 'TT_MS_LANGID_SAMI_LULE_SWEDEN' : 0x143b, + 'TT_MS_LANGID_SAMI_SOUTHERN_NORWAY' : 0x183b, + 'TT_MS_LANGID_SAMI_SOUTHERN_SWEDEN' : 0x1C3b, + 'TT_MS_LANGID_SAMI_SKOLT_FINLAND' : 0x203b, + 'TT_MS_LANGID_SAMI_INARI_FINLAND' : 0x243b, + 'TT_MS_LANGID_SAAMI_LAPONIA' : 0x043b, + 'TT_MS_LANGID_SCOTTISH_GAELIC_UNITED_KINGDOM' : 0x083c, + 'TT_MS_LANGID_IRISH_GAELIC_IRELAND' : 0x043c, + 'TT_MS_LANGID_YIDDISH_GERMANY' : 0x043d, + 'TT_MS_LANGID_MALAY_MALAYSIA' : 0x043e, + 'TT_MS_LANGID_MALAY_BRUNEI_DARUSSALAM' : 0x083e, + 'TT_MS_LANGID_KAZAK_KAZAKSTAN' : 0x043f, + 'TT_MS_LANGID_KIRGHIZ_KIRGHIZSTAN' : 0x0440, + 'TT_MS_LANGID_KIRGHIZ_KIRGHIZ_REPUBLIC' : 0x0440, + 'TT_MS_LANGID_SWAHILI_KENYA' : 0x0441, + 'TT_MS_LANGID_TURKMEN_TURKMENISTAN' : 0x0442, + 'TT_MS_LANGID_UZBEK_UZBEKISTAN_LATIN' : 0x0443, + 'TT_MS_LANGID_UZBEK_UZBEKISTAN_CYRILLIC' : 0x0843, + 'TT_MS_LANGID_TATAR_TATARSTAN' : 0x0444, + 'TT_MS_LANGID_BENGALI_INDIA' : 0x0445, + 'TT_MS_LANGID_BENGALI_BANGLADESH' : 0x0845, + 'TT_MS_LANGID_PUNJABI_INDIA' : 0x0446, + 'TT_MS_LANGID_PUNJABI_ARABIC_PAKISTAN' : 0x0846, + 'TT_MS_LANGID_GUJARATI_INDIA' : 0x0447, + 'TT_MS_LANGID_ORIYA_INDIA' : 0x0448, + 'TT_MS_LANGID_TAMIL_INDIA' : 0x0449, + 'TT_MS_LANGID_TELUGU_INDIA' : 0x044a, + 'TT_MS_LANGID_KANNADA_INDIA' : 0x044b, + 'TT_MS_LANGID_MALAYALAM_INDIA' : 0x044c, + 'TT_MS_LANGID_ASSAMESE_INDIA' : 0x044d, + 'TT_MS_LANGID_MARATHI_INDIA' : 0x044e, + 'TT_MS_LANGID_SANSKRIT_INDIA' : 0x044f, + 'TT_MS_LANGID_MONGOLIAN_MONGOLIA' : 0x0450, + 'TT_MS_LANGID_MONGOLIAN_MONGOLIA_MONGOLIAN' : 0x0850, + 'TT_MS_LANGID_TIBETAN_CHINA' : 0x0451, + 'TT_MS_LANGID_DZONGHKA_BHUTAN' : 0x0851, + 'TT_MS_LANGID_TIBETAN_BHUTAN' : 0x0851, + 'TT_MS_LANGID_WELSH_WALES' : 0x0452, + 'TT_MS_LANGID_KHMER_CAMBODIA' : 0x0453, + 'TT_MS_LANGID_LAO_LAOS' : 0x0454, + 'TT_MS_LANGID_BURMESE_MYANMAR' : 0x0455, + 'TT_MS_LANGID_GALICIAN_SPAIN' : 0x0456, + 'TT_MS_LANGID_KONKANI_INDIA' : 0x0457, + 'TT_MS_LANGID_MANIPURI_INDIA' : 0x0458, + 'TT_MS_LANGID_SINDHI_INDIA' : 0x0459, + 'TT_MS_LANGID_SINDHI_PAKISTAN' : 0x0859, + 'TT_MS_LANGID_SYRIAC_SYRIA' : 0x045a, + 'TT_MS_LANGID_SINHALESE_SRI_LANKA' : 0x045b, + 'TT_MS_LANGID_CHEROKEE_UNITED_STATES' : 0x045c, + 'TT_MS_LANGID_INUKTITUT_CANADA' : 0x045d, + 'TT_MS_LANGID_AMHARIC_ETHIOPIA' : 0x045e, + 'TT_MS_LANGID_TAMAZIGHT_MOROCCO' : 0x045f, + 'TT_MS_LANGID_TAMAZIGHT_MOROCCO_LATIN' : 0x085f, + 'TT_MS_LANGID_KASHMIRI_PAKISTAN' : 0x0460, + 'TT_MS_LANGID_KASHMIRI_SASIA' : 0x0860, + 'TT_MS_LANGID_KASHMIRI_INDIA' : 0x0860, + 'TT_MS_LANGID_NEPALI_NEPAL' : 0x0461, + 'TT_MS_LANGID_NEPALI_INDIA' : 0x0861, + 'TT_MS_LANGID_FRISIAN_NETHERLANDS' : 0x0462, + 'TT_MS_LANGID_PASHTO_AFGHANISTAN' : 0x0463, + 'TT_MS_LANGID_FILIPINO_PHILIPPINES' : 0x0464, + 'TT_MS_LANGID_DHIVEHI_MALDIVES' : 0x0465, + 'TT_MS_LANGID_DIVEHI_MALDIVES' : 0x0465, + 'TT_MS_LANGID_EDO_NIGERIA' : 0x0466, + 'TT_MS_LANGID_FULFULDE_NIGERIA' : 0x0467, + 'TT_MS_LANGID_HAUSA_NIGERIA' : 0x0468, + 'TT_MS_LANGID_IBIBIO_NIGERIA' : 0x0469, + 'TT_MS_LANGID_YORUBA_NIGERIA' : 0x046a, + 'TT_MS_LANGID_QUECHUA_BOLIVIA' : 0x046b, + 'TT_MS_LANGID_QUECHUA_ECUADOR' : 0x086b, + 'TT_MS_LANGID_QUECHUA_PERU' : 0x0c6b, + 'TT_MS_LANGID_SEPEDI_SOUTH_AFRICA' : 0x046c, + 'TT_MS_LANGID_SOTHO_SOUTHERN_SOUTH_AFRICA' : 0x046c, + 'TT_MS_LANGID_IGBO_NIGERIA' : 0x0470, + 'TT_MS_LANGID_KANURI_NIGERIA' : 0x0471, + 'TT_MS_LANGID_OROMO_ETHIOPIA' : 0x0472, + 'TT_MS_LANGID_TIGRIGNA_ETHIOPIA' : 0x0473, + 'TT_MS_LANGID_TIGRIGNA_ERYTHREA' : 0x0873, + 'TT_MS_LANGID_TIGRIGNA_ERYTREA' : 0x0873, + 'TT_MS_LANGID_GUARANI_PARAGUAY' : 0x0474, + 'TT_MS_LANGID_HAWAIIAN_UNITED_STATES' : 0x0475, + 'TT_MS_LANGID_LATIN' : 0x0476, + 'TT_MS_LANGID_SOMALI_SOMALIA' : 0x0477, + 'TT_MS_LANGID_YI_CHINA' : 0x0478, + 'TT_MS_LANGID_PAPIAMENTU_NETHERLANDS_ANTILLES' : 0x0479, + 'TT_MS_LANGID_UIGHUR_CHINA' : 0x0480, + 'TT_MS_LANGID_MAORI_NEW_ZEALAND' : 0x0481 } +globals().update(TT_MS_LANGIDS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_name_ids.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_name_ids.py new file mode 100644 index 0000000000000000000000000000000000000000..6b26be2919e42a26293ff5ff0dd3c43e2d7998fe --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_name_ids.py @@ -0,0 +1,91 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- + +""" +Possible values of the 'name' identifier field in the name records of the TTF +'name' table. These values are platform independent. + +TT_NAME_ID_COPYRIGHT + +TT_NAME_ID_FONT_FAMILY + +TT_NAME_ID_FONT_SUBFAMILY + +TT_NAME_ID_UNIQUE_ID + +TT_NAME_ID_FULL_NAME + +TT_NAME_ID_VERSION_STRING + +TT_NAME_ID_PS_NAME + +TT_NAME_ID_TRADEMARK + +TT_NAME_ID_MANUFACTURER + +TT_NAME_ID_DESIGNER + +TT_NAME_ID_DESCRIPTION + +TT_NAME_ID_VENDOR_URL + +TT_NAME_ID_DESIGNER_URL + +TT_NAME_ID_LICENSE + +TT_NAME_ID_LICENSE_URL + +TT_NAME_ID_PREFERRED_FAMILY + +TT_NAME_ID_PREFERRED_SUBFAMILY + +TT_NAME_ID_MAC_FULL_NAME + +TT_NAME_ID_SAMPLE_TEXT + +TT_NAME_ID_CID_FINDFONT_NAME + +TT_NAME_ID_WWS_FAMILY + +TT_NAME_ID_WWS_SUBFAMILY +""" + + +TT_NAME_IDS = { + 'TT_NAME_ID_COPYRIGHT' : 0, + 'TT_NAME_ID_FONT_FAMILY' : 1, + 'TT_NAME_ID_FONT_SUBFAMILY' : 2, + 'TT_NAME_ID_UNIQUE_ID' : 3, + 'TT_NAME_ID_FULL_NAME' : 4, + 'TT_NAME_ID_VERSION_STRING' : 5, + 'TT_NAME_ID_PS_NAME' : 6, + 'TT_NAME_ID_TRADEMARK' : 7, + + # the following values are from the OpenType spec + 'TT_NAME_ID_MANUFACTURER' : 8, + 'TT_NAME_ID_DESIGNER' : 9, + 'TT_NAME_ID_DESCRIPTION' : 10, + 'TT_NAME_ID_VENDOR_URL' : 11, + 'TT_NAME_ID_DESIGNER_URL' : 12, + 'TT_NAME_ID_LICENSE' : 13, + 'TT_NAME_ID_LICENSE_URL' : 14, + # number 15 is reserved + 'TT_NAME_ID_PREFERRED_FAMILY' : 16, + 'TT_NAME_ID_PREFERRED_SUBFAMILY' : 17, + 'TT_NAME_ID_MAC_FULL_NAME' : 18, + + # The following code is new as of 2000-01-21 + 'TT_NAME_ID_SAMPLE_TEXT' : 19, + + # This is new in OpenType 1.3 + 'TT_NAME_ID_CID_FINDFONT_NAME' : 20, + + # This is new in OpenType 1.5 + 'TT_NAME_ID_WWS_FAMILY' : 21, + 'TT_NAME_ID_WWS_SUBFAMILY' : 22 } +globals().update(TT_NAME_IDS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_platforms.py b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_platforms.py new file mode 100644 index 0000000000000000000000000000000000000000..4010176c78d0bd1cf5f717aa74ec4605718e3de1 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_enums/tt_platforms.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +""" +A list of valid values for the 'platform_id' identifier code in FT_CharMapRec +and FT_SfntName structures. + + +TT_PLATFORM_APPLE_UNICODE + + Used by Apple to indicate a Unicode character map and/or name entry. See + TT_APPLE_ID_XXX for corresponding 'encoding_id' values. Note that name + entries in this format are coded as big-endian UCS-2 character codes only. + + +TT_PLATFORM_MACINTOSH + + Used by Apple to indicate a MacOS-specific charmap and/or name entry. See + TT_MAC_ID_XXX for corresponding 'encoding_id' values. Note that most TrueType + fonts contain an Apple roman charmap to be usable on MacOS systems (even if + they contain a Microsoft charmap as well). + + +TT_PLATFORM_ISO + + This value was used to specify ISO/IEC 10646 charmaps. It is however now + deprecated. See TT_ISO_ID_XXX for a list of corresponding 'encoding_id' + values. + + +TT_PLATFORM_MICROSOFT + + Used by Microsoft to indicate Windows-specific charmaps. See TT_MS_ID_XXX for + a list of corresponding 'encoding_id' values. Note that most fonts contain a + Unicode charmap using (TT_PLATFORM_MICROSOFT, TT_MS_ID_UNICODE_CS). + + +TT_PLATFORM_CUSTOM + + Used to indicate application-specific charmaps. + + +TT_PLATFORM_ADOBE + + This value isn't part of any font format specification, but is used by + FreeType to report Adobe-specific charmaps in an FT_CharMapRec structure. See + TT_ADOBE_ID_XXX. +""" + +TT_PLATFORMS = { + 'TT_PLATFORM_APPLE_UNICODE' : 0, + 'TT_PLATFORM_MACINTOSH' : 1, + 'TT_PLATFORM_ISO' : 2, # deprecated + 'TT_PLATFORM_MICROSOFT' : 3, + 'TT_PLATFORM_CUSTOM' : 4, + 'TT_PLATFORM_ADOBE' : 7} # artificial +globals().update(TT_PLATFORMS) diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_errors.py b/vllm/lib/python3.10/site-packages/freetype/ft_errors.py new file mode 100644 index 0000000000000000000000000000000000000000..d080f15aed182ad21fbeff09ef17cbb6db9867c1 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_errors.py @@ -0,0 +1,118 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +''' +Internal exception with freetype error message +''' +class FT_Exception(Exception): + def __init__(self, errcode, message=''): + self.message = message + self.errcode = errcode + + def __str__(self): + return '%s: %s (%s)'%(self.__class__.__name__, self.message, + self._errors.get(self.errcode, 'unknown error')) + + _errors = { + 0x00: "no error" , + 0x01: "cannot open resource" , + 0x02: "unknown file format" , + 0x03: "broken file" , + 0x04: "invalid FreeType version" , + 0x05: "module version is too low" , + 0x06: "invalid argument" , + 0x07: "unimplemented feature" , + 0x08: "broken table" , + 0x09: "broken offset within table" , + 0x0A: "array allocation size too large" , + 0x0B: "missing module" , + 0x0C: "missing property" , + 0x10: "invalid glyph index" , + 0x11: "invalid character code" , + 0x12: "unsupported glyph image format" , + 0x13: "cannot render this glyph format" , + 0x14: "invalid outline" , + 0x15: "invalid composite glyph" , + 0x16: "too many hints" , + 0x17: "invalid pixel size" , + 0x18: "invalid SVG document" , + 0x20: "invalid object handle" , + 0x21: "invalid library handle" , + 0x22: "invalid module handle" , + 0x23: "invalid face handle" , + 0x24: "invalid size handle" , + 0x25: "invalid glyph slot handle" , + 0x26: "invalid charmap handle" , + 0x27: "invalid cache manager handle" , + 0x28: "invalid stream handle" , + 0x30: "too many modules" , + 0x31: "too many extensions" , + 0x40: "out of memory" , + 0x41: "unlisted object" , + 0x51: "cannot open stream" , + 0x52: "invalid stream seek" , + 0x53: "invalid stream skip" , + 0x54: "invalid stream read" , + 0x55: "invalid stream operation" , + 0x56: "invalid frame operation" , + 0x57: "nested frame access" , + 0x58: "invalid frame read" , + 0x60: "raster uninitialized" , + 0x61: "raster corrupted" , + 0x62: "raster overflow" , + 0x63: "negative height while rastering" , + 0x70: "too many registered caches" , + 0x80: "invalid opcode" , + 0x81: "too few arguments" , + 0x82: "stack overflow" , + 0x83: "code overflow" , + 0x84: "bad argument" , + 0x85: "division by zero" , + 0x86: "invalid reference" , + 0x87: "found debug opcode" , + 0x88: "found ENDF opcode in execution stream" , + 0x89: "nested DEFS" , + 0x8A: "invalid code range" , + 0x8B: "execution context too long" , + 0x8C: "too many function definitions" , + 0x8D: "too many instruction definitions" , + 0x8E: "SFNT font table missing" , + 0x8F: "horizontal header (hhea, table missing" , + 0x90: "locations (loca, table missing" , + 0x91: "name table missing" , + 0x92: "character map (cmap, table missing" , + 0x93: "horizontal metrics (hmtx, table missing" , + 0x94: "PostScript (post, table missing" , + 0x95: "invalid horizontal metrics" , + 0x96: "invalid character map (cmap, format" , + 0x97: "invalid ppem value" , + 0x98: "invalid vertical metrics" , + 0x99: "could not find context" , + 0x9A: "invalid PostScript (post, table format" , + 0x9B: "invalid PostScript (post, table" , + 0x9C: "found FDEF or IDEF opcode in glyf bytecode" , + 0x9D: "missing bitmap in strike" , + 0x9E: "SVG hooks have not been set", + 0xA0: "opcode syntax error" , + 0xA1: "argument stack underflow" , + 0xA2: "ignore" , + 0xA3: "no Unicode glyph name found" , + 0xA4: "glyph too big for hinting" , + 0xB0: "`STARTFONT' field missing" , + 0xB1: "`FONT' field missing" , + 0xB2: "`SIZE' field missing" , + 0xB3: "`FONTBOUNDINGBOX' field missing" , + 0xB4: "`CHARS' field missing" , + 0xB5: "`STARTCHAR' field missing" , + 0xB6: "`ENCODING' field missing" , + 0xB7: "`BBX' field missing" , + 0xB8: "`BBX' too big" , + 0xB9: "Font header corrupted or missing fields" , + 0xBA: "Font glyphs corrupted or missing fields" , + } + +FT_Err_Ok=0x00 diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_structs.py b/vllm/lib/python3.10/site-packages/freetype/ft_structs.py new file mode 100644 index 0000000000000000000000000000000000000000..a02f57d8e3384a66558a8d38f73f7dc06d916cd4 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_structs.py @@ -0,0 +1,1071 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +''' +Freetype structured types +------------------------- + +FT_Library: A handle to a FreeType library instance. + +FT_Vector: A simple structure used to store a 2D vector. + +FT_BBox: A structure used to hold an outline's bounding box. + +FT_Matrix: A simple structure used to store a 2x2 matrix. + +FT_UnitVector: A simple structure used to store a 2D vector unit vector. + +FT_Bitmap: A structure used to describe a bitmap or pixmap to the raster. + +FT_Data: Read-only binary data represented as a pointer and a length. + +FT_Generic: Client applications generic data. + +FT_Bitmap_Size: Metrics of a bitmap strike. + +FT_Charmap: The base charmap structure. + +FT_Glyph_Metrics:A structure used to model the metrics of a single glyph. + +FT_Outline: This structure is used to describe an outline to the scan-line + converter. + +FT_GlyphSlot: FreeType root glyph slot class structure. + +FT_Glyph: The root glyph structure contains a given glyph image plus its + advance width in 16.16 fixed float format. + +FT_Size_Metrics: The size metrics structure gives the metrics of a size object. + +FT_Size: FreeType root size class structure. + +FT_Face: FreeType root face class structure. + +FT_Parameter: A simple structure used to pass more or less generic parameters + to FT_Open_Face. + +FT_Open_Args: A structure used to indicate how to open a new font file or + stream. + +FT_SfntName: A structure used to model an SFNT 'name' table entry. + +FT_Stroker: Opaque handler to a path stroker object. + +FT_BitmapGlyph: A structure used for bitmap glyph images. +''' +from freetype.ft_types import * + + +# ----------------------------------------------------------------------------- +# A handle to a FreeType library instance. Each 'library' is completely +# independent from the others; it is the 'root' of a set of objects like fonts, +# faces, sizes, etc. +class FT_LibraryRec(Structure): + ''' + A handle to a FreeType library instance. Each 'library' is completely + independent from the others; it is the 'root' of a set of objects like + fonts, faces, sizes, etc. + ''' + _fields_ = [ ] +FT_Library = POINTER(FT_LibraryRec) + + + +# ----------------------------------------------------------------------------- +# A simple structure used to store a 2D vector; coordinates are of the FT_Pos +# type. +class FT_Vector(Structure): + ''' + A simple structure used to store a 2D vector; coordinates are of the FT_Pos + type. + + x: The horizontal coordinate. + y: The vertical coordinate. + ''' + _fields_ = [('x', FT_Pos), + ('y', FT_Pos)] + + + +# ----------------------------------------------------------------------------- +# A structure used to hold an outline's bounding box, i.e., the coordinates of +# its extrema in the horizontal and vertical directions. +# +# The bounding box is specified with the coordinates of the lower left and the +# upper right corner. In PostScript, those values are often called (llx,lly) +# and (urx,ury), respectively. +# +# If 'yMin' is negative, this value gives the glyph's descender. Otherwise, the +# glyph doesn't descend below the baseline. Similarly, if 'ymax' is positive, +# this value gives the glyph's ascender. +# +# 'xMin' gives the horizontal distance from the glyph's origin to the left edge +# of the glyph's bounding box. If 'xMin' is negative, the glyph extends to the +# left of the origin. +class FT_BBox(Structure): + ''' + A structure used to hold an outline's bounding box, i.e., the coordinates + of its extrema in the horizontal and vertical directions. + + The bounding box is specified with the coordinates of the lower left and + the upper right corner. In PostScript, those values are often called + (llx,lly) and (urx,ury), respectively. + + If 'yMin' is negative, this value gives the glyph's descender. Otherwise, + the glyph doesn't descend below the baseline. Similarly, if 'ymax' is + positive, this value gives the glyph's ascender. + + 'xMin' gives the horizontal distance from the glyph's origin to the left + edge of the glyph's bounding box. If 'xMin' is negative, the glyph extends + to the left of the origin. + + xMin: The horizontal minimum (left-most). + yMin: The vertical minimum (bottom-most). + xMax: The horizontal maximum (right-most). + yMax: The vertical maximum (top-most). + ''' + _fields_ = [('xMin', FT_Pos), + ('yMin', FT_Pos), + ('xMax', FT_Pos), + ('yMax', FT_Pos)] + + + +# ----------------------------------------------------------------------------- +# A simple structure used to store a 2x2 matrix. Coefficients are in 16.16 +# fixed float format. The computation performed is: +# x' = x*xx + y*xy +# y' = x*yx + y*yy +class FT_Matrix(Structure): + ''' + A simple structure used to store a 2x2 matrix. Coefficients are in 16.16 + fixed float format. The computation performed is: + + x' = x*xx + y*xy + y' = x*yx + y*yy + + xx: Matrix coefficient. + xy: Matrix coefficient. + yx: Matrix coefficient. + yy: Matrix coefficient. + ''' + _fields_ = [('xx', FT_Fixed), + ('xy', FT_Fixed), + ('yx', FT_Fixed), + ('yy', FT_Fixed)] + + + +# ----------------------------------------------------------------------------- +# A simple structure used to store a 2D vector unit vector. Uses FT_F2Dot14 +# types. +class FT_UnitVector(Structure): + ''' + A simple structure used to store a 2D vector unit vector. Uses FT_F2Dot14 + types. + + x: The horizontal coordinate. + y: The vertical coordinate. + ''' + _fields_ = [('x', FT_F2Dot14), + ('y', FT_F2Dot14)] + + + +# ----------------------------------------------------------------------------- +# A structure used to describe a bitmap or pixmap to the raster. Note that we +# now manage pixmaps of various depths through the 'pixel_mode' field. +class FT_Bitmap(Structure): + ''' + A structure used to describe a bitmap or pixmap to the raster. Note that we + now manage pixmaps of various depths through the 'pixel_mode' field. + + rows: The number of bitmap rows. + + width: The number of pixels in bitmap row. + + pitch: The pitch's absolute value is the number of bytes taken by one + bitmap row, including padding. However, the pitch is positive when + the bitmap has a 'down' flow, and negative when it has an 'up' + flow. In all cases, the pitch is an offset to add to a bitmap + pointer in order to go down one row. + + Note that 'padding' means the alignment of a bitmap to a byte + border, and FreeType functions normally align to the smallest + possible integer value. + + For the B/W rasterizer, 'pitch' is always an even number. + + To change the pitch of a bitmap (say, to make it a multiple of 4), + use FT_Bitmap_Convert. Alternatively, you might use callback + functions to directly render to the application's surface; see the + file 'example2.py' in the tutorial for a demonstration. + + buffer: A typeless pointer to the bitmap buffer. This value should be + aligned on 32-bit boundaries in most cases. + + num_grays: This field is only used with FT_PIXEL_MODE_GRAY; it gives the + number of gray levels used in the bitmap. + + pixel_mode: The pixel mode, i.e., how pixel bits are stored. See + FT_Pixel_Mode for possible values. + + palette_mode: This field is intended for paletted pixel modes; it indicates + how the palette is stored. Not used currently. + + palette: A typeless pointer to the bitmap palette; this field is intended + for paletted pixel modes. Not used currently. + ''' + _fields_ = [ + ('rows', c_int), + ('width', c_int), + ('pitch', c_int), + # declaring buffer as c_char_p confuses ctypes + ('buffer', POINTER(c_ubyte)), + ('num_grays', c_short), + ('pixel_mode', c_ubyte), + ('palette_mode', c_char), + ('palette', c_void_p) ] + + + +# ----------------------------------------------------------------------------- +# Read-only binary data represented as a pointer and a length. +# - While it is used internally within FreeType, the only public +# references to this structure are in include/freetype/ftincrem.h +# where it is used as glyph data bytes returned by incremental loading APIs. +# This is a specialist usage, and the only known use-case is +# by ghostscript, in ghostscript/base/fapi_ft.c . +# Hence there are no python examples for this. +class FT_Data(Structure): + ''' + Read-only binary data represented as a pointer and a length. + + pointer: The data. + length: The length of the data in bytes. + ''' + _fields_ = [('pointer', POINTER(FT_Byte)), + ('length', FT_UInt)] + + + +# ----------------------------------------------------------------------------- +# Client applications often need to associate their own data to a variety of +# FreeType core objects. For example, a text layout API might want to associate +# a glyph cache to a given size object. +# +# Most FreeType object contains a 'generic' field, of type FT_Generic, which +# usage is left to client applications and font servers. +# +# It can be used to store a pointer to client-specific data, as well as the +# address of a 'finalizer' function, which will be called by FreeType when the +# object is destroyed (for example, the previous client example would put the +# address of the glyph cache destructor in the 'finalizer' field). +class FT_Generic(Structure): + ''' + Client applications often need to associate their own data to a variety of + FreeType core objects. For example, a text layout API might want to + associate a glyph cache to a given size object. + + Most FreeType object contains a 'generic' field, of type FT_Generic, which + usage is left to client applications and font servers. + + It can be used to store a pointer to client-specific data, as well as the + address of a 'finalizer' function, which will be called by FreeType when + the object is destroyed (for example, the previous client example would put + the address of the glyph cache destructor in the 'finalizer' field). + + data: A typeless pointer to any client-specified data. This field is + completely ignored by the FreeType library. + finalizer: A pointer to a 'generic finalizer' function, which will be + called when the object is destroyed. If this field is set to + NULL, no code will be called. + ''' + _fields_ = [('data', c_void_p), + ('finalizer', FT_Generic_Finalizer)] + + + + +# ----------------------------------------------------------------------------- +# This structure models the metrics of a bitmap strike (i.e., a set of glyphs +# for a given point size and resolution) in a bitmap font. It is used for the +# 'available_sizes' field of FT_Face. +class FT_Bitmap_Size(Structure): + ''' + This structure models the metrics of a bitmap strike (i.e., a set of glyphs + for a given point size and resolution) in a bitmap font. It is used for the + 'available_sizes' field of FT_Face. + + height: The vertical distance, in pixels, between two consecutive + baselines. It is always positive. + + width: The average width, in pixels, of all glyphs in the strike. + + size: The nominal size of the strike in 26.6 fractional points. This field + is not very useful. + + x_ppem: The horizontal ppem (nominal width) in 26.6 fractional pixels. + + y_ppem: The vertical ppem (nominal height) in 26.6 fractional pixels. + ''' + _fields_ = [ + ('height', FT_Short), + ('width', FT_Short), + ('size', FT_Pos), + ('x_ppem', FT_Pos), + ('y_ppem', FT_Pos) ] + + + +# ----------------------------------------------------------------------------- +# The base charmap structure. +class FT_CharmapRec(Structure): + ''' + The base charmap structure. + + face : A handle to the parent face object. + + encoding : An FT_Encoding tag identifying the charmap. Use this with + FT_Select_Charmap. + + platform_id: An ID number describing the platform for the following + encoding ID. This comes directly from the TrueType + specification and should be emulated for other formats. + + encoding_id: A platform specific encoding number. This also comes from the + TrueType specification and should be emulated similarly. + ''' + _fields_ = [ + ('face', c_void_p), # Shoudl be FT_Face + ('encoding', FT_Encoding), + ('platform_id', FT_UShort), + ('encoding_id', FT_UShort), + ] +FT_Charmap = POINTER(FT_CharmapRec) + + + +# ----------------------------------------------------------------------------- +# A structure used to model the metrics of a single glyph. The values are +# expressed in 26.6 fractional pixel format; if the flag FT_LOAD_NO_SCALE has +# been used while loading the glyph, values are expressed in font units +# instead. +class FT_Glyph_Metrics(Structure): + ''' + A structure used to model the metrics of a single glyph. The values are + expressed in 26.6 fractional pixel format; if the flag FT_LOAD_NO_SCALE has + been used while loading the glyph, values are expressed in font units + instead. + + width: The glyph's width. + + height: The glyph's height. + + horiBearingX: Left side bearing for horizontal layout. + + horiBearingY: Top side bearing for horizontal layout. + + horiAdvance: Advance width for horizontal layout. + + vertBearingX: Left side bearing for vertical layout. + + vertBearingY: Top side bearing for vertical layout. + + vertAdvance: Advance height for vertical layout. + ''' + _fields_ = [ + ('width', FT_Pos), + ('height', FT_Pos), + ('horiBearingX', FT_Pos), + ('horiBearingY', FT_Pos), + ('horiAdvance', FT_Pos), + ('vertBearingX', FT_Pos), + ('vertBearingY', FT_Pos), + ('vertAdvance', FT_Pos), + ] + + + +# ----------------------------------------------------------------------------- +# This structure is used to describe an outline to the scan-line converter. +class FT_Outline(Structure): + ''' + This structure is used to describe an outline to the scan-line converter. + + n_contours: The number of contours in the outline. + + n_points: The number of points in the outline. + + points: A pointer to an array of 'n_points' FT_Vector elements, giving the + outline's point coordinates. + + tags: A pointer to an array of 'n_points' chars, giving each outline + point's type. + + If bit 0 is unset, the point is 'off' the curve, i.e., a Bezier + control point, while it is 'on' if set. + + Bit 1 is meaningful for 'off' points only. If set, it indicates a + third-order Bezier arc control point; and a second-order control + point if unset. + + If bit 2 is set, bits 5-7 contain the drop-out mode (as defined in + the OpenType specification; the value is the same as the argument to + the SCANMODE instruction). + + Bits 3 and 4 are reserved for internal purposes. + + contours: An array of 'n_contours' shorts, giving the end point of each + contour within the outline. For example, the first contour is + defined by the points '0' to 'contours[0]', the second one is + defined by the points 'contours[0]+1' to 'contours[1]', etc. + + flags: A set of bit flags used to characterize the outline and give hints + to the scan-converter and hinter on how to convert/grid-fit it. See + FT_OUTLINE_FLAGS. + ''' + _fields_ = [ + ('n_contours', c_short), + ('n_points', c_short), + ('points', POINTER(FT_Vector)), + # declaring buffer as c_char_p would prevent us to acces all tags + ('tags', POINTER(c_ubyte)), + ('contours', POINTER(c_short)), + ('flags', c_int), + ] + +# ----------------------------------------------------------------------------- +# Callback functions used in FT_Outline_Funcs + +FT_Outline_MoveToFunc = CFUNCTYPE(c_int, POINTER(FT_Vector), py_object) +FT_Outline_LineToFunc = CFUNCTYPE(c_int, POINTER(FT_Vector), py_object) +FT_Outline_ConicToFunc = CFUNCTYPE(c_int, POINTER(FT_Vector), POINTER(FT_Vector), py_object) +FT_Outline_CubicToFunc = CFUNCTYPE(c_int, POINTER(FT_Vector), POINTER(FT_Vector), POINTER(FT_Vector), py_object) + +# ----------------------------------------------------------------------------- +# Struct of callback functions for FT_Outline_Decompose() + +class FT_Outline_Funcs(Structure): + ''' + This structure holds a set of callbacks which are called by + FT_Outline_Decompose. + + move_to: Callback when outline needs to jump to a new path component. + + line_to: Callback to draw a straight line from the current position to + the control point. + + conic_to: Callback to draw a second-order Bézier curve from the current + position using the passed control points. + + curve_to: Callback to draw a third-order Bézier curve from the current + position using the passed control points. + + shift: Passed to FreeType which will transform vectors via + `x = (x << shift) - delta` and `y = (y << shift) - delta` + + delta: Passed to FreeType which will transform vectors via + `x = (x << shift) - delta` and `y = (y << shift) - delta` + ''' + _fields_ = [ + ('move_to', FT_Outline_MoveToFunc), + ('line_to', FT_Outline_LineToFunc), + ('conic_to', FT_Outline_ConicToFunc), + ('cubic_to', FT_Outline_CubicToFunc), + ('shift', c_int), + ('delta', FT_Pos), + ] + +# ----------------------------------------------------------------------------- +# The root glyph structure contains a given glyph image plus its advance width +# in 16.16 fixed float format. + +class FT_GlyphRec(Structure): + ''' + The root glyph structure contains a given glyph image plus its advance + width in 16.16 fixed float format. + + library: A handle to the FreeType library object. + + clazz: A pointer to the glyph's class. Private. + + format: The format of the glyph's image. + + advance: A 16.16 vector that gives the glyph's advance width. + ''' + _fields_ = [ + ('library', FT_Library), + ('clazz', c_void_p), + ('format', FT_Glyph_Format), + ('advance', FT_Vector) + ] +FT_Glyph = POINTER(FT_GlyphRec) + + + +# ----------------------------------------------------------------------------- +# FreeType root glyph slot class structure. A glyph slot is a container where +# individual glyphs can be loaded, be they in outline or bitmap format. +class FT_GlyphSlotRec(Structure): + ''' + FreeType root glyph slot class structure. A glyph slot is a container where + individual glyphs can be loaded, be they in outline or bitmap format. + + library: A handle to the FreeType library instance this slot belongs to. + + face: A handle to the parent face object. + + next: In some cases (like some font tools), several glyph slots per face + object can be a good thing. As this is rare, the glyph slots are + listed through a direct, single-linked list using its 'next' field. + + generic: A typeless pointer which is unused by the FreeType library or any + of its drivers. It can be used by client applications to link + their own data to each glyph slot object. + + metrics: The metrics of the last loaded glyph in the slot. The returned + values depend on the last load flags (see the FT_Load_Glyph API + function) and can be expressed either in 26.6 fractional pixels or + font units. + + Note that even when the glyph image is transformed, the metrics + are not. + + linearHoriAdvance: The advance width of the unhinted glyph. Its value is + expressed in 16.16 fractional pixels, unless + FT_LOAD_LINEAR_DESIGN is set when loading the + glyph. This field can be important to perform correct + WYSIWYG layout. Only relevant for outline glyphs. + + linearVertAdvance: The advance height of the unhinted glyph. Its value is + expressed in 16.16 fractional pixels, unless + FT_LOAD_LINEAR_DESIGN is set when loading the + glyph. This field can be important to perform correct + WYSIWYG layout. Only relevant for outline glyphs. + + advance: This shorthand is, depending on FT_LOAD_IGNORE_TRANSFORM, the + transformed advance width for the glyph (in 26.6 fractional pixel + format). As specified with FT_LOAD_VERTICAL_LAYOUT, it uses either + the 'horiAdvance' or the 'vertAdvance' value of 'metrics' field. + + format: This field indicates the format of the image contained in the glyph + slot. Typically FT_GLYPH_FORMAT_BITMAP, FT_GLYPH_FORMAT_OUTLINE, or + FT_GLYPH_FORMAT_COMPOSITE, but others are possible. + + bitmap: This field is used as a bitmap descriptor when the slot format is + FT_GLYPH_FORMAT_BITMAP. Note that the address and content of the + bitmap buffer can change between calls of FT_Load_Glyph and a few + other functions. + + bitmap_left: This is the bitmap's left bearing expressed in integer + pixels. Of course, this is only valid if the format is + FT_GLYPH_FORMAT_BITMAP. + + bitmap_top: This is the bitmap's top bearing expressed in integer + pixels. Remember that this is the distance from the baseline to + the top-most glyph scanline, upwards y coordinates being + positive. + + outline: The outline descriptor for the current glyph image if its format + is FT_GLYPH_FORMAT_OUTLINE. Once a glyph is loaded, 'outline' can + be transformed, distorted, embolded, etc. However, it must not be + freed. + + num_subglyphs: The number of subglyphs in a composite glyph. This field is + only valid for the composite glyph format that should + normally only be loaded with the FT_LOAD_NO_RECURSE + flag. For now this is internal to FreeType. + + subglyphs: An array of subglyph descriptors for composite glyphs. There are + 'num_subglyphs' elements in there. Currently internal to + FreeType. + + control_data: Certain font drivers can also return the control data for a + given glyph image (e.g. TrueType bytecode, Type 1 + charstrings, etc.). This field is a pointer to such data. + + control_len: This is the length in bytes of the control data. + + other: Really wicked formats can use this pointer to present their own + glyph image to client applications. Note that the application needs + to know about the image format. + + lsb_delta: The difference between hinted and unhinted left side bearing + while autohinting is active. Zero otherwise. + + rsb_delta: The difference between hinted and unhinted right side bearing + while autohinting is active. Zero otherwise. + ''' + _fields_ = [ + ('library', FT_Library), + ('face', c_void_p), + ('next', c_void_p), + ('glyph_index', c_uint), # new in FreeType 2.10; was reserved previously and retained for binary compatibility + ('generic', FT_Generic), + + ('metrics', FT_Glyph_Metrics), + ('linearHoriAdvance', FT_Fixed), + ('linearVertAdvance', FT_Fixed), + ('advance', FT_Vector), + + ('format', FT_Glyph_Format), + + ('bitmap', FT_Bitmap), + ('bitmap_left', FT_Int), + ('bitmap_top', FT_Int), + + ('outline', FT_Outline), + ('num_subglyphs', FT_UInt), + ('subglyphs', c_void_p), + + ('control_data', c_void_p), + ('control_len', c_long), + + ('lsb_delta', FT_Pos), + ('rsb_delta', FT_Pos), + ('other', c_void_p), + ('internal', c_void_p), + ] +FT_GlyphSlot = POINTER(FT_GlyphSlotRec) + + + +# ----------------------------------------------------------------------------- +# The size metrics structure gives the metrics of a size object. +class FT_Size_Metrics(Structure): + ''' + The size metrics structure gives the metrics of a size object. + + x_ppem: The width of the scaled EM square in pixels, hence the term 'ppem' + (pixels per EM). It is also referred to as 'nominal width'. + + y_ppem: The height of the scaled EM square in pixels, hence the term 'ppem' + (pixels per EM). It is also referred to as 'nominal height'. + + x_scale: A 16.16 fractional scaling value used to convert horizontal + metrics from font units to 26.6 fractional pixels. Only relevant + for scalable font formats. + + y_scale: A 16.16 fractional scaling value used to convert vertical metrics + from font units to 26.6 fractional pixels. Only relevant for + scalable font formats. + + ascender: The ascender in 26.6 fractional pixels. See FT_FaceRec for the + details. + + descender: The descender in 26.6 fractional pixels. See FT_FaceRec for the + details. + + height: The height in 26.6 fractional pixels. See FT_FaceRec for the + details. + + max_advance: The maximal advance width in 26.6 fractional pixels. See + FT_FaceRec for the details. + ''' + _fields_ = [ + ('x_ppem', FT_UShort), + ('y_ppem', FT_UShort), + + ('x_scale', FT_Fixed), + ('y_scale', FT_Fixed), + + ('ascender', FT_Pos), + ('descender', FT_Pos), + ('height', FT_Pos), + ('max_advance', FT_Pos), + ] + + + +# ----------------------------------------------------------------------------- +# FreeType root size class structure. A size object models a face object at a +# given size. +class FT_SizeRec(Structure): + ''' + FreeType root size class structure. A size object models a face object at a + given size. + + face: Handle to the parent face object. + + generic: A typeless pointer, which is unused by the FreeType library or any + of its drivers. It can be used by client applications to link + their own data to each size object. + + metrics: Metrics for this size object. This field is read-only. + ''' + _fields_ = [ + ('face', c_void_p), + ('generic', FT_Generic), + ('metrics', FT_Size_Metrics), + ('internal', c_void_p), + ] +FT_Size = POINTER(FT_SizeRec) + + + +# ----------------------------------------------------------------------------- +# FreeType root face class structure. A face object models a typeface in a font +# file. +class FT_FaceRec(Structure): + ''' + FreeType root face class structure. A face object models a typeface in a + font file. + + num_faces: The number of faces in the font file. Some font formats can have + multiple faces in a font file. + + face_index: The index of the face in the font file. It is set to 0 if there + is only one face in the font file. + + face_flags: A set of bit flags that give important information about the + face; see FT_FACE_FLAG_XXX for the details. + + style_flags: A set of bit flags indicating the style of the face; see + FT_STYLE_FLAG_XXX for the details. + + num_glyphs: The number of glyphs in the face. If the face is scalable and + has sbits (see 'num_fixed_sizes'), it is set to the number of + outline glyphs. + + For CID-keyed fonts, this value gives the highest CID used in + the font. + + family_name: The face's family name. This is an ASCII string, usually in + English, which describes the typeface's family (like 'Times + New Roman', 'Bodoni', 'Garamond', etc). This is a least common + denominator used to list fonts. Some formats (TrueType & + OpenType) provide localized and Unicode versions of this + string. Applications should use the format specific interface + to access them. Can be NULL (e.g., in fonts embedded in a PDF + file). + + style_name: The face's style name. This is an ASCII string, usually in + English, which describes the typeface's style (like 'Italic', + 'Bold', 'Condensed', etc). Not all font formats provide a style + name, so this field is optional, and can be set to NULL. As for + 'family_name', some formats provide localized and Unicode + versions of this string. Applications should use the format + specific interface to access them. + + num_fixed_sizes: The number of bitmap strikes in the face. Even if the face + is scalable, there might still be bitmap strikes, which + are called 'sbits' in that case. + + available_sizes: An array of FT_Bitmap_Size for all bitmap strikes in the + face. It is set to NULL if there is no bitmap strike. + + num_charmaps: The number of charmaps in the face. + + charmaps: An array of the charmaps of the face. + + generic: A field reserved for client uses. See the FT_Generic type + description. + + bbox: The font bounding box. Coordinates are expressed in font units (see + 'units_per_EM'). The box is large enough to contain any glyph from + the font. Thus, 'bbox.yMax' can be seen as the 'maximal ascender', + and 'bbox.yMin' as the 'minimal descender'. Only relevant for + scalable formats. + + Note that the bounding box might be off by (at least) one pixel for + hinted fonts. See FT_Size_Metrics for further discussion. + + units_per_EM: The number of font units per EM square for this face. This is + typically 2048 for TrueType fonts, and 1000 for Type 1 + fonts. Only relevant for scalable formats. + + ascender: The typographic ascender of the face, expressed in font + units. For font formats not having this information, it is set to + 'bbox.yMax'. Only relevant for scalable formats. + + descender: The typographic descender of the face, expressed in font + units. For font formats not having this information, it is set + to 'bbox.yMin'. Note that this field is usually negative. Only + relevant for scalable formats. + + height: The height is the vertical distance between two consecutive + baselines, expressed in font units. It is always positive. Only + relevant for scalable formats. + + max_advance_width: The maximal advance width, in font units, for all glyphs + in this face. This can be used to make word wrapping + computations faster. Only relevant for scalable formats. + + max_advance_height: The maximal advance height, in font units, for all + glyphs in this face. This is only relevant for vertical + layouts, and is set to 'height' for fonts that do not + provide vertical metrics. Only relevant for scalable + formats. + + underline_position: The position, in font units, of the underline line for + this face. It is the center of the underlining + stem. Only relevant for scalable formats. + + underline_thickness: The thickness, in font units, of the underline for + this face. Only relevant for scalable formats. + + glyph: The face's associated glyph slot(s). + + size: The current active size for this face. + + charmap: The current active charmap for this face. + ''' + _fields_ = [ + ('num_faces', FT_Long), + ('face_index', FT_Long), + + ('face_flags', FT_Long), + ('style_flags', FT_Long), + + ('num_glyphs', FT_Long), + + ('family_name', FT_String_p), + ('style_name', FT_String_p), + + ('num_fixed_sizes', FT_Int), + ('available_sizes', POINTER(FT_Bitmap_Size)), + + ('num_charmaps', c_int), + ('charmaps', POINTER(FT_Charmap)), + + ('generic', FT_Generic), + + # The following member variables (down to `underline_thickness') + # are only relevant to scalable outlines; cf. @FT_Bitmap_Size + # for bitmap fonts. + ('bbox', FT_BBox), + + ('units_per_EM', FT_UShort), + ('ascender', FT_Short), + ('descender', FT_Short), + ('height', FT_Short), + + ('max_advance_width', FT_Short), + ('max_advance_height', FT_Short), + + ('underline_position', FT_Short), + ('underline_thickness', FT_Short), + + ('glyph', FT_GlyphSlot), + ('size', FT_Size), + ('charmap', FT_Charmap), + + # private + ('driver', c_void_p), + ('memory', c_void_p), + ('stream', c_void_p), + ('sizes_list_head', c_void_p), + ('sizes_list_tail', c_void_p), + ('autohint', FT_Generic), + ('extensions', c_void_p), + ('internal', c_void_p), + ] +FT_Face = POINTER(FT_FaceRec) + + + +# ----------------------------------------------------------------------------- +# A simple structure used to pass more or less generic parameters to +# FT_Open_Face. +class FT_Parameter(Structure): + ''' + A simple structure used to pass more or less generic parameters to + FT_Open_Face. + + tag: A four-byte identification tag. + + data: A pointer to the parameter data + ''' + _fields_ = [ + ('tag', FT_ULong), + ('data', FT_Pointer) ] +FT_Parameter_p = POINTER(FT_Parameter) + + + +# ----------------------------------------------------------------------------- +# A structure used to indicate how to open a new font file or stream. A pointer +# to such a structure can be used as a parameter for the functions FT_Open_Face +# and FT_Attach_Stream. +class FT_Open_Args(Structure): + ''' + A structure used to indicate how to open a new font file or stream. A pointer + to such a structure can be used as a parameter for the functions FT_Open_Face + and FT_Attach_Stream. + + flags: A set of bit flags indicating how to use the structure. + + memory_base: The first byte of the file in memory. + + memory_size: The size in bytes of the file in memory. + + pathname: A pointer to an 8-bit file pathname. + + stream: A handle to a source stream object. + + driver: This field is exclusively used by FT_Open_Face; it simply specifies + the font driver to use to open the face. If set to 0, FreeType + tries to load the face with each one of the drivers in its list. + + num_params: The number of extra parameters. + + params: Extra parameters passed to the font driver when opening a new face. + ''' + _fields_ = [ + ('flags', FT_UInt), + ('memory_base', POINTER(FT_Byte)), + ('memory_size', FT_Long), + ('pathname', FT_String_p), + ('stream', c_void_p), + ('driver', c_void_p), + ('num_params', FT_Int), + ('params', FT_Parameter_p) ] + + + +# ----------------------------------------------------------------------------- +# A structure used to model an SFNT 'name' table entry. + +class FT_SfntName(Structure): + ''' + platform_id: The platform ID for 'string'. + + encoding_id: The encoding ID for 'string'. + + language_id: The language ID for 'string' + + name_id: An identifier for 'string' + + string: The 'name' string. Note that its format differs depending on the + (platform,encoding) pair. It can be a Pascal String, a UTF-16 one, + etc. + + Generally speaking, the string is not zero-terminated. Please refer + to the TrueType specification for details. + + string_len: The length of 'string' in bytes. + ''' + + _fields_ = [ + ('platform_id', FT_UShort), + ('encoding_id', FT_UShort), + ('language_id', FT_UShort), + ('name_id', FT_UShort), + # this string is *not* null-terminated! + ('string', POINTER(FT_Byte)), + ('string_len', FT_UInt) ] + + + +# ----------------------------------------------------------------------------- +# Opaque handler to a path stroker object. +class FT_StrokerRec(Structure): + ''' + Opaque handler to a path stroker object. + ''' + _fields_ = [ ] +FT_Stroker = POINTER(FT_StrokerRec) + + +# ----------------------------------------------------------------------------- +# A structure used for bitmap glyph images. This really is a 'sub-class' of +# FT_GlyphRec. +# +class FT_BitmapGlyphRec(Structure): + ''' + A structure used for bitmap glyph images. This really is a 'sub-class' of + FT_GlyphRec. + ''' + _fields_ = [ + ('root' , FT_GlyphRec), + ('left', FT_Int), + ('top', FT_Int), + ('bitmap', FT_Bitmap) + ] +FT_BitmapGlyph = POINTER(FT_BitmapGlyphRec) + + +# ----------------------------------------------------------------------------- +# Structures related to variable fonts as used in the various VF routines. +# +class FT_Var_Axis(Structure): + ''' + A structure to model a given axis in design space for Multiple Masters, + TrueType GX, and OpenType variation fonts. + ''' + _fields_ = [ + ('name', FT_String_p), + ('minimum', FT_Fixed), + ('default', FT_Fixed), + ('maximum', FT_Fixed), + ('tag', FT_ULong), + ('strid', FT_UInt) + ] + + +class FT_Var_Named_Style(Structure): + ''' + A structure to model a named instance in a TrueType GX or OpenType + variation font. + ''' + _fields_ = [ + ('coords', POINTER(FT_Fixed)), + ('strid', FT_UInt), + ('psid', FT_UInt) + ] + + +class FT_MM_Var(Structure): + ''' + A structure to model the axes and space of an Adobe MM, TrueType GX, + or OpenType variation font. + Some fields are specific to one format and not to the others. + ''' + _fields_ = [ + ('num_axis', FT_UInt), + ('num_designs', FT_UInt), + ('num_namedstyles', FT_UInt), + ('axis', POINTER(FT_Var_Axis)), + ('namedstyle', POINTER(FT_Var_Named_Style)) + ] +# ----------------------------------------------------------------------------- +# Structures related to OT-SVG support. See "freetype/otsvg.h". +# +SVG_Lib_Init_Func = CFUNCTYPE(c_int, POINTER(py_object)) +SVG_Lib_Free_Func = CFUNCTYPE(None, POINTER(py_object)) +SVG_Lib_Render_Func = CFUNCTYPE(c_int, FT_GlyphSlot, POINTER(py_object)) +SVG_Lib_Preset_Slot_Func = CFUNCTYPE(c_int, FT_GlyphSlot, FT_Bool, POINTER(py_object)) + +class SVG_RendererHooks(Structure): + _fields_ = [('svg_init', SVG_Lib_Init_Func), + ('svg_free', SVG_Lib_Free_Func), + ('svg_render', SVG_Lib_Render_Func), + ('svg_preset_slot', SVG_Lib_Preset_Slot_Func)] + +class FT_SVG_DocumentRec(Structure): + _fields_ = [('svg_document', POINTER(FT_Byte)), + ('svg_document_length', FT_ULong), + ('metrics', FT_Size_Metrics), + ('units_per_EM', FT_UShort), + ('start_glyph_id', FT_UShort), + ('end_glyph_id', FT_UShort), + ('transform', FT_Matrix), + ('delta', FT_Vector)] + +FT_SVG_Document = POINTER(FT_SVG_DocumentRec) +# ----------------------------------------------------------------------------- +# Structures related to color support. See "freetype/ftcolor.h". +# +class FT_OpaquePaint(Structure): + _fields_ = [('p', POINTER(FT_Byte)), + ('insert_root_transform', FT_Bool)] +class FT_LayerIterator(Structure): + _fields_ = [('num_layers', FT_UInt), + ('layer', FT_UInt), + ('p', POINTER(FT_Byte))] diff --git a/vllm/lib/python3.10/site-packages/freetype/ft_types.py b/vllm/lib/python3.10/site-packages/freetype/ft_types.py new file mode 100644 index 0000000000000000000000000000000000000000..6fbe729b4ba695de6bc9bc0284eb79e21e469f6d --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/ft_types.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# +# FreeType high-level python API - Copyright 2011 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# +# ----------------------------------------------------------------------------- +''' +Freetype basic data types +------------------------- + +FT_Byte : A simple typedef for the unsigned char type. + +FT_Bytes : A typedef for constant memory areas. + +FT_Char : A simple typedef for the signed char type. + +FT_Int : A typedef for the int type. + +FT_UInt : A typedef for the unsigned int type. + +FT_Int16 : A typedef for a 16bit signed integer type. + +FT_UInt16 : A typedef for a 16bit unsigned integer type. + +FT_Int32 : A typedef for a 32bit signed integer type. + +FT_UInt32 : A typedef for a 32bit unsigned integer type. + +FT_Short : A typedef for signed short. + +FT_UShort : A typedef for unsigned short. + +FT_Long : A typedef for signed long. + +FT_ULong : A typedef for unsigned long. + +FT_Bool : A typedef of unsigned char, used for simple booleans. As usual, + values 1 and 0 represent true and false, respectively. + +FT_Offset : This is equivalent to the ANSI C 'size_t' type, i.e., the largest + unsigned integer type used to express a file size or position, or + a memory block size. + +FT_PtrDist : This is equivalent to the ANSI C 'ptrdiff_t' type, i.e., the + largest signed integer type used to express the distance between + two pointers. + +FT_String : A simple typedef for the char type, usually used for strings. + +FT_Tag : A typedef for 32-bit tags (as used in the SFNT format). + +FT_Error : The FreeType error code type. A value of 0 is always interpreted as + a successful operation. + +FT_Fixed : This type is used to store 16.16 fixed float values, like scaling + values or matrix coefficients. + +FT_Pointer : A simple typedef for a typeless pointer. + +FT_Pos : The type FT_Pos is used to store vectorial coordinates. Depending on + the context, these can represent distances in integer font units, or + 16.16, or 26.6 fixed float pixel coordinates. + +FT_FWord : A signed 16-bit integer used to store a distance in original font + units. + +FT_UFWord : An unsigned 16-bit integer used to store a distance in original + font units. + +FT_F2Dot14 : A signed 2.14 fixed float type used for unit vectors. + +FT_F26Dot6 : A signed 26.6 fixed float type used for vectorial pixel + coordinates. +''' +from ctypes import * + + +FT_Byte = c_ubyte # A simple typedef for the unsigned char type. + +FT_Bytes = c_char_p # A typedef for constant memory areas. + +FT_Char = c_char # A simple typedef for the signed char type. + +FT_Int = c_int # A typedef for the int type. + +FT_UInt = c_uint # A typedef for the unsigned int type. + +FT_Int16 = c_short # A typedef for a 16bit signed integer type. + +FT_UInt16 = c_ushort # A typedef for a 16bit unsigned integer type. + +FT_Int32 = c_int32 # A typedef for a 32bit signed integer type. + +FT_UInt32 = c_uint32 # A typedef for a 32bit unsigned integer type. + +FT_Short = c_short # A typedef for signed short. + +FT_UShort = c_ushort # A typedef for unsigned short. + +FT_Long = c_long # A typedef for signed long. + +FT_ULong = c_ulong # A typedef for unsigned long. + +FT_Bool = c_char # A typedef of unsigned char, used for simple booleans. As + # usual, values 1 and 0 represent true and false, + # respectively. + +FT_Offset = c_size_t # This is equivalent to the ANSI C 'size_t' type, i.e., + # the largest unsigned integer type used to express a file + # size or position, or a memory block size. + +FT_PtrDist = c_longlong # This is equivalent to the ANSI C 'ptrdiff_t' type, + # i.e., the largest signed integer type used to express + # the distance between two pointers. + +FT_String = c_char # A simple typedef for the char type, usually used for strings. + +FT_String_p= c_char_p + +FT_Tag = FT_UInt32 # A typedef for 32-bit tags (as used in the SFNT format). + +FT_Error = c_int # The FreeType error code type. A value of 0 is always + # interpreted as a successful operation. + +FT_Fixed = c_long # This type is used to store 16.16 fixed float values, + # like scaling values or matrix coefficients. + +FT_Angle = FT_Fixed # This type is used to model angle values in FreeType. Note that the + # angle is a 16.16 fixed-point value expressed in degrees. + +FT_Pointer = c_void_p # A simple typedef for a typeless pointer. + +FT_Pos = c_long # The type FT_Pos is used to store vectorial + # coordinates. Depending on the context, these can + # represent distances in integer font units, or 16.16, or + # 26.6 fixed float pixel coordinates. + +FT_FWord = c_short # A signed 16-bit integer used to store a distance in + # original font units. + +FT_UFWord = c_ushort # An unsigned 16-bit integer used to store a distance in + # original font units. + +FT_F2Dot14 = c_short # A signed 2.14 fixed float type used for unit vectors. + +FT_F26Dot6 = c_long # A signed 26.6 fixed float type used for vectorial pixel + # coordinates. + +FT_Glyph_Format = c_int + +FT_Encoding = c_int + + +# Describe a function used to destroy the 'client' data of any FreeType +# object. See the description of the FT_Generic type for details of usage. +FT_Generic_Finalizer = CFUNCTYPE(None, c_void_p) diff --git a/vllm/lib/python3.10/site-packages/freetype/libfreetype.so b/vllm/lib/python3.10/site-packages/freetype/libfreetype.so new file mode 100644 index 0000000000000000000000000000000000000000..411b399a36270fd8946bd95ecdab91aa28e22b8d --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/libfreetype.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:33f7bb37f65553ecc4d273d51a79fb152d4f0cd1cdd13b8477c76a90fce09b7d +size 2159248 diff --git a/vllm/lib/python3.10/site-packages/freetype/raw.py b/vllm/lib/python3.10/site-packages/freetype/raw.py new file mode 100644 index 0000000000000000000000000000000000000000..ffc101be48e0d609b10182ba2540a09ca6fcc501 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/freetype/raw.py @@ -0,0 +1,338 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# FreeType high-level python API - Copyright 2011-2015 Nicolas P. Rougier +# Distributed under the terms of the new BSD license. +# ----------------------------------------------------------------------------- +''' +Freetype raw API + +This is the raw ctypes freetype binding. +''' +import os +import platform +from ctypes import * +import ctypes.util + +import freetype +from freetype.ft_types import * +from freetype.ft_enums import * +from freetype.ft_errors import * +from freetype.ft_structs import * + +# First, look for a bundled FreeType shared object on the top-level of the +# installed freetype-py module. +system = platform.system() +if system == 'Windows': + library_name = 'libfreetype.dll' +elif system == 'Darwin': + library_name = 'libfreetype.dylib' +else: + library_name = 'libfreetype.so' + +filename = os.path.join(os.path.dirname(freetype.__file__), library_name) + +# If no bundled shared object is found, look for a system-wide installed one. +if not os.path.exists(filename): + # on windows all ctypes does when checking for the library + # is to append .dll to the end and look for an exact match + # within any entry in PATH. + filename = ctypes.util.find_library('freetype') + + if filename is None: + if platform.system() == 'Windows': + # Check current working directory for dll as ctypes fails to do so + filename = os.path.join(os.path.realpath('.'), "freetype.dll") + else: + filename = library_name + +try: + _lib = ctypes.CDLL(filename) +except (OSError, TypeError): + _lib = None + raise RuntimeError('Freetype library not found') + +FT_Init_FreeType = _lib.FT_Init_FreeType +FT_Done_FreeType = _lib.FT_Done_FreeType +FT_Library_Version = _lib.FT_Library_Version + +try: + FT_Library_SetLcdFilter= _lib.FT_Library_SetLcdFilter +except AttributeError: + def FT_Library_SetLcdFilter (*args, **kwargs): + return 0 +try: + FT_Library_SetLcdFilterWeights = _lib.FT_Library_SetLcdFilterWeights +except AttributeError: + pass + +FT_New_Face = _lib.FT_New_Face +FT_New_Memory_Face = _lib.FT_New_Memory_Face +FT_Open_Face = _lib.FT_Open_Face +FT_Attach_File = _lib.FT_Attach_File +FT_Attach_Stream = _lib.FT_Attach_Stream + +try: + FT_Reference_Face = _lib.FT_Reference_Face +except AttributeError: + pass + +FT_Done_Face = _lib.FT_Done_Face +FT_Done_Glyph = _lib.FT_Done_Glyph +FT_Select_Size = _lib.FT_Select_Size +FT_Request_Size = _lib.FT_Request_Size +FT_Set_Char_Size = _lib.FT_Set_Char_Size +FT_Set_Pixel_Sizes = _lib.FT_Set_Pixel_Sizes +FT_Load_Glyph = _lib.FT_Load_Glyph +FT_Load_Char = _lib.FT_Load_Char +FT_Set_Transform = _lib.FT_Set_Transform +FT_Render_Glyph = _lib.FT_Render_Glyph +FT_Get_Kerning = _lib.FT_Get_Kerning +FT_Get_Track_Kerning = _lib.FT_Get_Track_Kerning +FT_Get_Glyph_Name = _lib.FT_Get_Glyph_Name +FT_Get_Glyph = _lib.FT_Get_Glyph + +FT_Glyph_Get_CBox = _lib.FT_Glyph_Get_CBox + +FT_Get_Postscript_Name = _lib.FT_Get_Postscript_Name +FT_Get_Postscript_Name.restype = c_char_p +FT_Select_Charmap = _lib.FT_Select_Charmap +FT_Set_Charmap = _lib.FT_Set_Charmap +FT_Get_Charmap_Index = _lib.FT_Get_Charmap_Index +FT_Get_CMap_Language_ID= _lib.FT_Get_CMap_Language_ID +try: + #introduced between 2.2.x and 2.3.x + FT_Get_CMap_Format = _lib.FT_Get_CMap_Format +except AttributeError: + pass +FT_Get_Char_Index = _lib.FT_Get_Char_Index +FT_Get_First_Char = _lib.FT_Get_First_Char +FT_Get_Next_Char = _lib.FT_Get_Next_Char +FT_Get_Name_Index = _lib.FT_Get_Name_Index +FT_Get_SubGlyph_Info = _lib.FT_Get_SubGlyph_Info + +try: + FT_Get_FSType_Flags = _lib.FT_Get_FSType_Flags + FT_Get_FSType_Flags.restype = c_ushort +except AttributeError: + pass + +FT_Get_X11_Font_Format = _lib.FT_Get_X11_Font_Format +FT_Get_X11_Font_Format.restype = c_char_p + +FT_Get_Sfnt_Name_Count = _lib.FT_Get_Sfnt_Name_Count +FT_Get_Sfnt_Name = _lib.FT_Get_Sfnt_Name +try: + # introduced between 2.2.x and 2.3.x + FT_Get_Advance = _lib.FT_Get_Advance +except AttributeError: + pass + + +FT_Outline_GetInsideBorder = _lib.FT_Outline_GetInsideBorder +FT_Outline_GetOutsideBorder = _lib.FT_Outline_GetOutsideBorder +FT_Outline_Get_BBox = _lib.FT_Outline_Get_BBox +FT_Outline_Get_CBox = _lib.FT_Outline_Get_CBox +try: + # since 2.4.10 + FT_Outline_EmboldenXY = _lib.FT_Outline_EmboldenXY +except AttributeError: + pass +FT_Stroker_New = _lib.FT_Stroker_New +FT_Stroker_Set = _lib.FT_Stroker_Set +FT_Stroker_Rewind = _lib.FT_Stroker_Rewind +FT_Stroker_ParseOutline = _lib.FT_Stroker_ParseOutline +FT_Stroker_BeginSubPath = _lib.FT_Stroker_BeginSubPath +FT_Stroker_EndSubPath = _lib.FT_Stroker_EndSubPath +FT_Stroker_LineTo = _lib.FT_Stroker_LineTo +FT_Stroker_ConicTo = _lib.FT_Stroker_ConicTo +FT_Stroker_CubicTo = _lib.FT_Stroker_CubicTo +FT_Stroker_GetBorderCounts = _lib.FT_Stroker_GetBorderCounts +FT_Stroker_ExportBorder = _lib.FT_Stroker_ExportBorder +FT_Stroker_GetCounts = _lib.FT_Stroker_GetCounts +FT_Stroker_Export = _lib.FT_Stroker_Export +FT_Stroker_Done = _lib.FT_Stroker_Done +FT_Glyph_Stroke = _lib.FT_Glyph_Stroke +FT_Glyph_StrokeBorder = _lib.FT_Glyph_StrokeBorder +FT_Glyph_To_Bitmap = _lib.FT_Glyph_To_Bitmap + + +# FT_Property_Get/FT_Property_Set requires FreeType 2.7.x+ +try: + FT_Property_Get = _lib.FT_Property_Get + FT_Property_Set = _lib.FT_Property_Set +except AttributeError: + pass + +# These two are only found when TT debugger is enabled +try: + TT_New_Context = _lib.TT_New_Context + TT_RunIns = _lib.TT_RunIns +except AttributeError: + pass + + +# Routines for variable font support. These were introduced at different +# points in FreeType's history (except for FT_Get_MM_Var which has been +# around for a long time). +FT_Get_MM_Var = _lib.FT_Get_MM_Var # v2.old + +# -- since 2.8.1 for sure (some 2.7.1 or possibly older, but to be safe, +# implementation should check FT version >= 2.8.1 +try: + FT_Get_Var_Axis_Flags = _lib.FT_Get_Var_Axis_Flags + FT_Get_Var_Blend_Coordinates = _lib.FT_Get_Var_Blend_Coordinates + FT_Get_Var_Design_Coordinates = _lib.FT_Get_Var_Design_Coordinates + FT_Set_Var_Blend_Coordinates = _lib.FT_Set_Var_Blend_Coordinates + FT_Set_Var_Design_Coordinates = _lib.FT_Set_Var_Design_Coordinates +except AttributeError: + pass + +# -- since v2.9; we can work around if these are not present. +try: + FT_Done_MM_Var = _lib.FT_Done_MM_Var + FT_Set_Named_Instance = _lib.FT_Set_Named_Instance +except AttributeError: + pass + +# Wholesale import of 102 routines which can be reasonably expected +# to be found in freetype 2.2.x onwards. Some of these might need +# to be protected with try:/except AttributeError: in some freetype builds. + +FTC_CMapCache_Lookup = _lib.FTC_CMapCache_Lookup +FTC_CMapCache_New = _lib.FTC_CMapCache_New +FTC_ImageCache_Lookup = _lib.FTC_ImageCache_Lookup +FTC_ImageCache_New = _lib.FTC_ImageCache_New +FTC_Manager_Done = _lib.FTC_Manager_Done +FTC_Manager_LookupFace = _lib.FTC_Manager_LookupFace +FTC_Manager_LookupSize = _lib.FTC_Manager_LookupSize +FTC_Manager_New = _lib.FTC_Manager_New +FTC_Manager_RemoveFaceID = _lib.FTC_Manager_RemoveFaceID +FTC_Manager_Reset = _lib.FTC_Manager_Reset +FTC_Node_Unref = _lib.FTC_Node_Unref +FTC_SBitCache_Lookup = _lib.FTC_SBitCache_Lookup +FTC_SBitCache_New = _lib.FTC_SBitCache_New + +FT_Activate_Size = _lib.FT_Activate_Size +FT_Add_Default_Modules = _lib.FT_Add_Default_Modules +FT_Add_Module = _lib.FT_Add_Module +FT_Angle_Diff = _lib.FT_Angle_Diff +FT_Atan2 = _lib.FT_Atan2 +FT_Bitmap_Convert = _lib.FT_Bitmap_Convert +FT_Bitmap_Copy = _lib.FT_Bitmap_Copy +FT_Bitmap_Done = _lib.FT_Bitmap_Done +FT_Bitmap_Embolden = _lib.FT_Bitmap_Embolden +FT_Bitmap_New = _lib.FT_Bitmap_New +FT_CeilFix = _lib.FT_CeilFix +FT_ClassicKern_Free = _lib.FT_ClassicKern_Free +FT_ClassicKern_Validate = _lib.FT_ClassicKern_Validate +FT_Cos = _lib.FT_Cos +FT_DivFix = _lib.FT_DivFix +FT_Done_Library = _lib.FT_Done_Library +FT_Done_Size = _lib.FT_Done_Size +FT_FloorFix = _lib.FT_FloorFix +try: + # Not in default windows build of 2.8.x + FT_Get_BDF_Charset_ID = _lib.FT_Get_BDF_Charset_ID + FT_Get_BDF_Property = _lib.FT_Get_BDF_Property +except AttributeError: + pass +try: + FT_Get_Color_Glyph_Layer = _lib.FT_Get_Color_Glyph_Layer # 2.10 + FT_Get_Color_Glyph_Layer.restype = FT_Bool + FT_Get_Color_Glyph_Layer.argtypes = [FT_Face, FT_UInt, POINTER(FT_UInt), POINTER(FT_UInt), POINTER(FT_LayerIterator)] + FT_Get_Color_Glyph_Paint = _lib.FT_Get_Color_Glyph_Paint # 2.13 + FT_Get_Color_Glyph_Paint.restype = FT_Bool + FT_Get_Color_Glyph_Paint.argtypes = [FT_Face, FT_UInt, + FT_UInt, # FT_Color_Root_Transform enums + POINTER(FT_OpaquePaint)] +except AttributeError: + pass +try: + FT_Face_GetCharVariantIndex = _lib.FT_Face_GetCharVariantIndex + FT_Face_GetCharVariantIndex.argtypes = [FT_Face, FT_ULong, FT_ULong] + FT_Face_GetCharVariantIndex.restype = FT_UInt + + FT_Face_GetCharVariantIsDefault = _lib.FT_Face_GetCharVariantIsDefault + FT_Face_GetCharVariantIsDefault.argtypes = [FT_Face, FT_ULong, FT_ULong] + FT_Face_GetCharVariantIsDefault.restype = FT_Int + + FT_Face_GetVariantSelectors = _lib.FT_Face_GetVariantSelectors + FT_Face_GetVariantSelectors.argtypes = [FT_Face] + FT_Face_GetVariantSelectors.restype = POINTER(FT_UInt32) + + FT_Face_GetVariantsOfChar = _lib.FT_Face_GetVariantsOfChar + FT_Face_GetVariantsOfChar.argtypes = [FT_Face, FT_ULong] + FT_Face_GetVariantsOfChar.restype = POINTER(FT_UInt32) + + FT_Face_GetCharsOfVariant = _lib.FT_Face_GetCharsOfVariant + FT_Face_GetVariantsOfChar.argtypes = [FT_Face, FT_ULong] + FT_Face_GetCharsOfVariant.restype = POINTER(FT_UInt32) +except AttributeError: + pass +FT_Get_Module = _lib.FT_Get_Module +FT_Get_Multi_Master = _lib.FT_Get_Multi_Master +FT_Get_PFR_Advance = _lib.FT_Get_PFR_Advance +FT_Get_PFR_Kerning = _lib.FT_Get_PFR_Kerning +FT_Get_PFR_Metrics = _lib.FT_Get_PFR_Metrics +FT_Get_PS_Font_Info = _lib.FT_Get_PS_Font_Info +FT_Get_PS_Font_Private = _lib.FT_Get_PS_Font_Private +FT_Get_Renderer = _lib.FT_Get_Renderer +FT_Get_Sfnt_Table = _lib.FT_Get_Sfnt_Table +FT_Get_TrueType_Engine_Type = _lib.FT_Get_TrueType_Engine_Type +FT_Get_WinFNT_Header = _lib.FT_Get_WinFNT_Header +FT_Glyph_Copy = _lib.FT_Glyph_Copy +FT_GlyphSlot_Embolden = _lib.FT_GlyphSlot_Embolden +FT_GlyphSlot_Oblique = _lib.FT_GlyphSlot_Oblique +FT_GlyphSlot_Own_Bitmap = _lib.FT_GlyphSlot_Own_Bitmap +FT_Glyph_Transform = _lib.FT_Glyph_Transform +FT_Has_PS_Glyph_Names = _lib.FT_Has_PS_Glyph_Names +FT_List_Add = _lib.FT_List_Add +FT_List_Finalize = _lib.FT_List_Finalize +FT_List_Find = _lib.FT_List_Find +FT_List_Insert = _lib.FT_List_Insert +FT_List_Iterate = _lib.FT_List_Iterate +FT_List_Remove = _lib.FT_List_Remove +FT_List_Up = _lib.FT_List_Up +FT_Load_Sfnt_Table = _lib.FT_Load_Sfnt_Table +FT_Matrix_Invert = _lib.FT_Matrix_Invert +FT_Matrix_Multiply = _lib.FT_Matrix_Multiply +FT_MulDiv = _lib.FT_MulDiv +FT_MulFix = _lib.FT_MulFix +FT_New_Library = _lib.FT_New_Library +FT_New_Size = _lib.FT_New_Size +FT_OpenType_Free = _lib.FT_OpenType_Free +FT_OpenType_Validate = _lib.FT_OpenType_Validate +FT_Outline_Check = _lib.FT_Outline_Check +FT_Outline_Copy = _lib.FT_Outline_Copy +FT_Outline_Decompose = _lib.FT_Outline_Decompose +FT_Outline_Done = _lib.FT_Outline_Done +FT_Outline_Embolden = _lib.FT_Outline_Embolden +FT_Outline_Get_Bitmap = _lib.FT_Outline_Get_Bitmap +FT_Outline_Get_Orientation = _lib.FT_Outline_Get_Orientation +FT_Outline_New = _lib.FT_Outline_New +FT_Outline_Render = _lib.FT_Outline_Render +FT_Outline_Reverse = _lib.FT_Outline_Reverse +FT_Outline_Transform = _lib.FT_Outline_Transform +FT_Outline_Translate = _lib.FT_Outline_Translate +FT_Remove_Module = _lib.FT_Remove_Module +FT_Render_Glyph = _lib.FT_Render_Glyph +FT_RoundFix = _lib.FT_RoundFix +FT_Set_Debug_Hook = _lib.FT_Set_Debug_Hook +FT_Set_MM_Blend_Coordinates = _lib.FT_Set_MM_Blend_Coordinates +FT_Set_MM_Design_Coordinates = _lib.FT_Set_MM_Design_Coordinates +FT_Set_Renderer = _lib.FT_Set_Renderer +FT_Sfnt_Table_Info = _lib.FT_Sfnt_Table_Info +FT_Sin = _lib.FT_Sin +FT_Stream_OpenGzip = _lib.FT_Stream_OpenGzip +FT_Stream_OpenLZW = _lib.FT_Stream_OpenLZW +FT_Tan = _lib.FT_Tan +FT_TrueTypeGX_Free = _lib.FT_TrueTypeGX_Free +FT_TrueTypeGX_Validate = _lib.FT_TrueTypeGX_Validate +FT_Vector_From_Polar = _lib.FT_Vector_From_Polar +FT_Vector_Length = _lib.FT_Vector_Length +FT_Vector_Polarize = _lib.FT_Vector_Polarize +FT_Vector_Rotate = _lib.FT_Vector_Rotate +FT_Vector_Transform = _lib.FT_Vector_Transform +FT_Vector_Unit = _lib.FT_Vector_Unit + +# Wholesale import ends diff --git a/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/INSTALLER b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/LICENSE.txt b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..7bb1330a1002b78e748296b4be96a72f3fb67b4e --- /dev/null +++ b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/LICENSE.txt @@ -0,0 +1,2261 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +-------------------------------------------------------------------------------- + +src/arrow/util (some portions): Apache 2.0, and 3-clause BSD + +Some portions of this module are derived from code in the Chromium project, +copyright (c) Google inc and (c) The Chromium Authors and licensed under the +Apache 2.0 License or the under the 3-clause BSD license: + + Copyright (c) 2013 The Chromium Authors. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +This project includes code from Daniel Lemire's FrameOfReference project. + +https://github.com/lemire/FrameOfReference/blob/6ccaf9e97160f9a3b299e23a8ef739e711ef0c71/src/bpacking.cpp +https://github.com/lemire/FrameOfReference/blob/146948b6058a976bc7767262ad3a2ce201486b93/scripts/turbopacking64.py + +Copyright: 2013 Daniel Lemire +Home page: http://lemire.me/en/ +Project page: https://github.com/lemire/FrameOfReference +License: Apache License Version 2.0 http://www.apache.org/licenses/LICENSE-2.0 + +-------------------------------------------------------------------------------- + +This project includes code from the TensorFlow project + +Copyright 2015 The TensorFlow Authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +-------------------------------------------------------------------------------- + +This project includes code from the NumPy project. + +https://github.com/numpy/numpy/blob/e1f191c46f2eebd6cb892a4bfe14d9dd43a06c4e/numpy/core/src/multiarray/multiarraymodule.c#L2910 + +https://github.com/numpy/numpy/blob/68fd82271b9ea5a9e50d4e761061dfcca851382a/numpy/core/src/multiarray/datetime.c + +Copyright (c) 2005-2017, NumPy Developers. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the NumPy Developers nor the names of any + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +This project includes code from the Boost project + +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +-------------------------------------------------------------------------------- + +This project includes code from the FlatBuffers project + +Copyright 2014 Google Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +-------------------------------------------------------------------------------- + +This project includes code from the tslib project + +Copyright 2015 Microsoft Corporation. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +-------------------------------------------------------------------------------- + +This project includes code from the jemalloc project + +https://github.com/jemalloc/jemalloc + +Copyright (C) 2002-2017 Jason Evans . +All rights reserved. +Copyright (C) 2007-2012 Mozilla Foundation. All rights reserved. +Copyright (C) 2009-2017 Facebook, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +1. Redistributions of source code must retain the above copyright notice(s), + this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice(s), + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY EXPRESS +OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +-------------------------------------------------------------------------------- + +This project includes code from the Go project, BSD 3-clause license + PATENTS +weak patent termination clause +(https://github.com/golang/go/blob/master/PATENTS). + +Copyright (c) 2009 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +This project includes code from the hs2client + +https://github.com/cloudera/hs2client + +Copyright 2016 Cloudera Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +-------------------------------------------------------------------------------- + +The script ci/scripts/util_wait_for_it.sh has the following license + +Copyright (c) 2016 Giles Hall + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +The script r/configure has the following license (MIT) + +Copyright (c) 2017, Jeroen Ooms and Jim Hester + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +cpp/src/arrow/util/logging.cc, cpp/src/arrow/util/logging.h and +cpp/src/arrow/util/logging-test.cc are adapted from +Ray Project (https://github.com/ray-project/ray) (Apache 2.0). + +Copyright (c) 2016 Ray Project (https://github.com/ray-project/ray) + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +-------------------------------------------------------------------------------- +The files cpp/src/arrow/vendored/datetime/date.h, cpp/src/arrow/vendored/datetime/tz.h, +cpp/src/arrow/vendored/datetime/tz_private.h, cpp/src/arrow/vendored/datetime/ios.h, +cpp/src/arrow/vendored/datetime/ios.mm, +cpp/src/arrow/vendored/datetime/tz.cpp are adapted from +Howard Hinnant's date library (https://github.com/HowardHinnant/date) +It is licensed under MIT license. + +The MIT License (MIT) +Copyright (c) 2015, 2016, 2017 Howard Hinnant +Copyright (c) 2016 Adrian Colomitchi +Copyright (c) 2017 Florian Dang +Copyright (c) 2017 Paul Thompson +Copyright (c) 2018 Tomasz Kamiński + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +The file cpp/src/arrow/util/utf8.h includes code adapted from the page + https://bjoern.hoehrmann.de/utf-8/decoder/dfa/ +with the following license (MIT) + +Copyright (c) 2008-2009 Bjoern Hoehrmann + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +The files in cpp/src/arrow/vendored/xxhash/ have the following license +(BSD 2-Clause License) + +xxHash Library +Copyright (c) 2012-2014, Yann Collet +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +You can contact the author at : +- xxHash homepage: http://www.xxhash.com +- xxHash source repository : https://github.com/Cyan4973/xxHash + +-------------------------------------------------------------------------------- + +The files in cpp/src/arrow/vendored/double-conversion/ have the following license +(BSD 3-Clause License) + +Copyright 2006-2011, the V8 project authors. All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +The files in cpp/src/arrow/vendored/uriparser/ have the following license +(BSD 3-Clause License) + +uriparser - RFC 3986 URI parsing library + +Copyright (C) 2007, Weijia Song +Copyright (C) 2007, Sebastian Pipping +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + * Neither the name of the nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED +OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +The files under dev/tasks/conda-recipes have the following license + +BSD 3-clause license +Copyright (c) 2015-2018, conda-forge +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +The files in cpp/src/arrow/vendored/utfcpp/ have the following license + +Copyright 2006-2018 Nemanja Trifunovic + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +-------------------------------------------------------------------------------- + +This project includes code from Apache Kudu. + + * cpp/cmake_modules/CompilerInfo.cmake is based on Kudu's cmake_modules/CompilerInfo.cmake + +Copyright: 2016 The Apache Software Foundation. +Home page: https://kudu.apache.org/ +License: http://www.apache.org/licenses/LICENSE-2.0 + +-------------------------------------------------------------------------------- + +This project includes code from Apache Impala (incubating), formerly +Impala. The Impala code and rights were donated to the ASF as part of the +Incubator process after the initial code imports into Apache Parquet. + +Copyright: 2012 Cloudera, Inc. +Copyright: 2016 The Apache Software Foundation. +Home page: http://impala.apache.org/ +License: http://www.apache.org/licenses/LICENSE-2.0 + +-------------------------------------------------------------------------------- + +This project includes code from Apache Aurora. + +* dev/release/{release,changelog,release-candidate} are based on the scripts from + Apache Aurora + +Copyright: 2016 The Apache Software Foundation. +Home page: https://aurora.apache.org/ +License: http://www.apache.org/licenses/LICENSE-2.0 + +-------------------------------------------------------------------------------- + +This project includes code from the Google styleguide. + +* cpp/build-support/cpplint.py is based on the scripts from the Google styleguide. + +Copyright: 2009 Google Inc. All rights reserved. +Homepage: https://github.com/google/styleguide +License: 3-clause BSD + +-------------------------------------------------------------------------------- + +This project includes code from Snappy. + +* cpp/cmake_modules/{SnappyCMakeLists.txt,SnappyConfig.h} are based on code + from Google's Snappy project. + +Copyright: 2009 Google Inc. All rights reserved. +Homepage: https://github.com/google/snappy +License: 3-clause BSD + +-------------------------------------------------------------------------------- + +This project includes code from the manylinux project. + +* python/manylinux1/scripts/{build_python.sh,python-tag-abi-tag.py, + requirements.txt} are based on code from the manylinux project. + +Copyright: 2016 manylinux +Homepage: https://github.com/pypa/manylinux +License: The MIT License (MIT) + +-------------------------------------------------------------------------------- + +This project includes code from the cymove project: + +* python/pyarrow/includes/common.pxd includes code from the cymove project + +The MIT License (MIT) +Copyright (c) 2019 Omer Ozarslan + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +OR OTHER DEALINGS IN THE SOFTWARE. + +-------------------------------------------------------------------------------- + +The projects includes code from the Ursabot project under the dev/archery +directory. + +License: BSD 2-Clause + +Copyright 2019 RStudio, Inc. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +This project include code from mingw-w64. + +* cpp/src/arrow/util/cpu-info.cc has a polyfill for mingw-w64 < 5 + +Copyright (c) 2009 - 2013 by the mingw-w64 project +Homepage: https://mingw-w64.org +License: Zope Public License (ZPL) Version 2.1. + +--------------------------------------------------------------------------------- + +This project include code from Google's Asylo project. + +* cpp/src/arrow/result.h is based on status_or.h + +Copyright (c) Copyright 2017 Asylo authors +Homepage: https://asylo.dev/ +License: Apache 2.0 + +-------------------------------------------------------------------------------- + +This project includes code from Google's protobuf project + +* cpp/src/arrow/result.h ARROW_ASSIGN_OR_RAISE is based off ASSIGN_OR_RETURN +* cpp/src/arrow/util/bit_stream_utils.h contains code from wire_format_lite.h + +Copyright 2008 Google Inc. All rights reserved. +Homepage: https://developers.google.com/protocol-buffers/ +License: + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Code generated by the Protocol Buffer compiler is owned by the owner +of the input file used when generating it. This code is not +standalone and requires a support library to be linked with it. This +support library is itself covered by the above license. + +-------------------------------------------------------------------------------- + +3rdparty dependency LLVM is statically linked in certain binary distributions. +Additionally some sections of source code have been derived from sources in LLVM +and have been clearly labeled as such. LLVM has the following license: + +============================================================================== +The LLVM Project is under the Apache License v2.0 with LLVM Exceptions: +============================================================================== + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +---- LLVM Exceptions to the Apache 2.0 License ---- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into an Object form of such source code, you +may redistribute such embedded portions in such Object form without complying +with the conditions of Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link compiled forms of this Software with +software that is licensed under the GPLv2 ("Combined Software") and if a +court of competent jurisdiction determines that the patent provision (Section +3), the indemnity provision (Section 9) or other Section of the License +conflicts with the conditions of the GPLv2, you may retroactively and +prospectively choose to deem waived or otherwise exclude such Section(s) of +the License, but only in their entirety and only with respect to the Combined +Software. + +============================================================================== +Software from third parties included in the LLVM Project: +============================================================================== +The LLVM Project contains third party software which is under different license +terms. All such code will be identified clearly using at least one of two +mechanisms: +1) It will be in a separate directory tree with its own `LICENSE.txt` or + `LICENSE` file at the top containing the specific license and restrictions + which apply to that software, or +2) It will contain specific license and restriction terms at the top of every + file. + +-------------------------------------------------------------------------------- + +3rdparty dependency gRPC is statically linked in certain binary +distributions, like the python wheels. gRPC has the following license: + +Copyright 2014 gRPC authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +-------------------------------------------------------------------------------- + +3rdparty dependency Apache Thrift is statically linked in certain binary +distributions, like the python wheels. Apache Thrift has the following license: + +Apache Thrift +Copyright (C) 2006 - 2019, The Apache Software Foundation + +This product includes software developed at +The Apache Software Foundation (http://www.apache.org/). + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +-------------------------------------------------------------------------------- + +3rdparty dependency Apache ORC is statically linked in certain binary +distributions, like the python wheels. Apache ORC has the following license: + +Apache ORC +Copyright 2013-2019 The Apache Software Foundation + +This product includes software developed by The Apache Software +Foundation (http://www.apache.org/). + +This product includes software developed by Hewlett-Packard: +(c) Copyright [2014-2015] Hewlett-Packard Development Company, L.P + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +-------------------------------------------------------------------------------- + +3rdparty dependency zstd is statically linked in certain binary +distributions, like the python wheels. ZSTD has the following license: + +BSD License + +For Zstandard software + +Copyright (c) 2016-present, Facebook, Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Facebook nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +3rdparty dependency lz4 is statically linked in certain binary +distributions, like the python wheels. lz4 has the following license: + +LZ4 Library +Copyright (c) 2011-2016, Yann Collet +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +3rdparty dependency Brotli is statically linked in certain binary +distributions, like the python wheels. Brotli has the following license: + +Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +-------------------------------------------------------------------------------- + +3rdparty dependency rapidjson is statically linked in certain binary +distributions, like the python wheels. rapidjson and its dependencies have the +following licenses: + +Tencent is pleased to support the open source community by making RapidJSON +available. + +Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. +All rights reserved. + +If you have downloaded a copy of the RapidJSON binary from Tencent, please note +that the RapidJSON binary is licensed under the MIT License. +If you have downloaded a copy of the RapidJSON source code from Tencent, please +note that RapidJSON source code is licensed under the MIT License, except for +the third-party components listed below which are subject to different license +terms. Your integration of RapidJSON into your own projects may require +compliance with the MIT License, as well as the other licenses applicable to +the third-party components included within RapidJSON. To avoid the problematic +JSON license in your own projects, it's sufficient to exclude the +bin/jsonchecker/ directory, as it's the only code under the JSON license. +A copy of the MIT License is included in this file. + +Other dependencies and licenses: + + Open Source Software Licensed Under the BSD License: + -------------------------------------------------------------------- + + The msinttypes r29 + Copyright (c) 2006-2013 Alexander Chemeris + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + DAMAGE. + + Terms of the MIT License: + -------------------------------------------------------------------- + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + +-------------------------------------------------------------------------------- + +3rdparty dependency snappy is statically linked in certain binary +distributions, like the python wheels. snappy has the following license: + +Copyright 2011, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of Google Inc. nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=== + +Some of the benchmark data in testdata/ is licensed differently: + + - fireworks.jpeg is Copyright 2013 Steinar H. Gunderson, and + is licensed under the Creative Commons Attribution 3.0 license + (CC-BY-3.0). See https://creativecommons.org/licenses/by/3.0/ + for more information. + + - kppkn.gtb is taken from the Gaviota chess tablebase set, and + is licensed under the MIT License. See + https://sites.google.com/site/gaviotachessengine/Home/endgame-tablebases-1 + for more information. + + - paper-100k.pdf is an excerpt (bytes 92160 to 194560) from the paper + “Combinatorial Modeling of Chromatin Features Quantitatively Predicts DNA + Replication Timing in _Drosophila_” by Federico Comoglio and Renato Paro, + which is licensed under the CC-BY license. See + http://www.ploscompbiol.org/static/license for more ifnormation. + + - alice29.txt, asyoulik.txt, plrabn12.txt and lcet10.txt are from Project + Gutenberg. The first three have expired copyrights and are in the public + domain; the latter does not have expired copyright, but is still in the + public domain according to the license information + (http://www.gutenberg.org/ebooks/53). + +-------------------------------------------------------------------------------- + +3rdparty dependency gflags is statically linked in certain binary +distributions, like the python wheels. gflags has the following license: + +Copyright (c) 2006, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +3rdparty dependency glog is statically linked in certain binary +distributions, like the python wheels. glog has the following license: + +Copyright (c) 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +A function gettimeofday in utilities.cc is based on + +http://www.google.com/codesearch/p?hl=en#dR3YEbitojA/COPYING&q=GetSystemTimeAsFileTime%20license:bsd + +The license of this code is: + +Copyright (c) 2003-2008, Jouni Malinen and contributors +All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. Neither the name(s) of the above-listed copyright holder(s) nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +3rdparty dependency re2 is statically linked in certain binary +distributions, like the python wheels. re2 has the following license: + +Copyright (c) 2009 The RE2 Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google Inc. nor the names of its contributors + may be used to endorse or promote products derived from this + software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +3rdparty dependency c-ares is statically linked in certain binary +distributions, like the python wheels. c-ares has the following license: + +# c-ares license + +Copyright (c) 2007 - 2018, Daniel Stenberg with many contributors, see AUTHORS +file. + +Copyright 1998 by the Massachusetts Institute of Technology. + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, provided that +the above copyright notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting documentation, and that +the name of M.I.T. not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior permission. +M.I.T. makes no representations about the suitability of this software for any +purpose. It is provided "as is" without express or implied warranty. + +-------------------------------------------------------------------------------- + +3rdparty dependency zlib is redistributed as a dynamically linked shared +library in certain binary distributions, like the python wheels. In the future +this will likely change to static linkage. zlib has the following license: + +zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.11, January 15th, 2017 + + Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + +-------------------------------------------------------------------------------- + +3rdparty dependency openssl is redistributed as a dynamically linked shared +library in certain binary distributions, like the python wheels. openssl +preceding version 3 has the following license: + + LICENSE ISSUES + ============== + + The OpenSSL toolkit stays under a double license, i.e. both the conditions of + the OpenSSL License and the original SSLeay license apply to the toolkit. + See below for the actual license texts. + + OpenSSL License + --------------- + +/* ==================================================================== + * Copyright (c) 1998-2019 The OpenSSL Project. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. All advertising materials mentioning features or use of this + * software must display the following acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" + * + * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For written permission, please contact + * openssl-core@openssl.org. + * + * 5. Products derived from this software may not be called "OpenSSL" + * nor may "OpenSSL" appear in their names without prior written + * permission of the OpenSSL Project. + * + * 6. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit (http://www.openssl.org/)" + * + * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY + * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * ==================================================================== + * + * This product includes cryptographic software written by Eric Young + * (eay@cryptsoft.com). This product includes software written by Tim + * Hudson (tjh@cryptsoft.com). + * + */ + + Original SSLeay License + ----------------------- + +/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) + * All rights reserved. + * + * This package is an SSL implementation written + * by Eric Young (eay@cryptsoft.com). + * The implementation was written so as to conform with Netscapes SSL. + * + * This library is free for commercial and non-commercial use as long as + * the following conditions are aheared to. The following conditions + * apply to all code found in this distribution, be it the RC4, RSA, + * lhash, DES, etc., code; not just the SSL code. The SSL documentation + * included with this distribution is covered by the same copyright terms + * except that the holder is Tim Hudson (tjh@cryptsoft.com). + * + * Copyright remains Eric Young's, and as such any Copyright notices in + * the code are not to be removed. + * If this package is used in a product, Eric Young should be given attribution + * as the author of the parts of the library used. + * This can be in the form of a textual message at program startup or + * in documentation (online or textual) provided with the package. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * "This product includes cryptographic software written by + * Eric Young (eay@cryptsoft.com)" + * The word 'cryptographic' can be left out if the rouines from the library + * being used are not cryptographic related :-). + * 4. If you include any Windows specific code (or a derivative thereof) from + * the apps directory (application code) you must include an acknowledgement: + * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" + * + * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * The licence and distribution terms for any publically available version or + * derivative of this code cannot be changed. i.e. this code cannot simply be + * copied and put under another distribution licence + * [including the GNU Public Licence.] + */ + +-------------------------------------------------------------------------------- + +This project includes code from the rtools-backports project. + +* ci/scripts/PKGBUILD and ci/scripts/r_windows_build.sh are based on code + from the rtools-backports project. + +Copyright: Copyright (c) 2013 - 2019, Алексей and Jeroen Ooms. +All rights reserved. +Homepage: https://github.com/r-windows/rtools-backports +License: 3-clause BSD + +-------------------------------------------------------------------------------- + +Some code from pandas has been adapted for the pyarrow codebase. pandas is +available under the 3-clause BSD license, which follows: + +pandas license +============== + +Copyright (c) 2011-2012, Lambda Foundry, Inc. and PyData Development Team +All rights reserved. + +Copyright (c) 2008-2011 AQR Capital Management, LLC +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the copyright holder nor the names of any + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +Some bits from DyND, in particular aspects of the build system, have been +adapted from libdynd and dynd-python under the terms of the BSD 2-clause +license + +The BSD 2-Clause License + + Copyright (C) 2011-12, Dynamic NDArray Developers + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Dynamic NDArray Developers list: + + * Mark Wiebe + * Continuum Analytics + +-------------------------------------------------------------------------------- + +Some source code from Ibis (https://github.com/cloudera/ibis) has been adapted +for PyArrow. Ibis is released under the Apache License, Version 2.0. + +-------------------------------------------------------------------------------- + +dev/tasks/homebrew-formulae/apache-arrow.rb has the following license: + +BSD 2-Clause License + +Copyright (c) 2009-present, Homebrew contributors +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---------------------------------------------------------------------- + +cpp/src/arrow/vendored/base64.cpp has the following license + +ZLIB License + +Copyright (C) 2004-2017 René Nyffenegger + +This source code is provided 'as-is', without any express or implied +warranty. In no event will the author be held liable for any damages arising +from the use of this software. + +Permission is granted to anyone to use this software for any purpose, including +commercial applications, and to alter it and redistribute it freely, subject to +the following restrictions: + +1. The origin of this source code must not be misrepresented; you must not + claim that you wrote the original source code. If you use this source code + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original source code. + +3. This notice may not be removed or altered from any source distribution. + +René Nyffenegger rene.nyffenegger@adp-gmbh.ch + +-------------------------------------------------------------------------------- + +This project includes code from Folly. + + * cpp/src/arrow/vendored/ProducerConsumerQueue.h + +is based on Folly's + + * folly/Portability.h + * folly/lang/Align.h + * folly/ProducerConsumerQueue.h + +Copyright: Copyright (c) Facebook, Inc. and its affiliates. +Home page: https://github.com/facebook/folly +License: http://www.apache.org/licenses/LICENSE-2.0 + +-------------------------------------------------------------------------------- + +The file cpp/src/arrow/vendored/musl/strptime.c has the following license + +Copyright © 2005-2020 Rich Felker, et al. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +-------------------------------------------------------------------------------- + +The file cpp/cmake_modules/BuildUtils.cmake contains code from + +https://gist.github.com/cristianadam/ef920342939a89fae3e8a85ca9459b49 + +which is made available under the MIT license + +Copyright (c) 2019 Cristian Adam + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +The files in cpp/src/arrow/vendored/portable-snippets/ contain code from + +https://github.com/nemequ/portable-snippets + +and have the following copyright notice: + +Each source file contains a preamble explaining the license situation +for that file, which takes priority over this file. With the +exception of some code pulled in from other repositories (such as +µnit, an MIT-licensed project which is used for testing), the code is +public domain, released using the CC0 1.0 Universal dedication (*). + +(*) https://creativecommons.org/publicdomain/zero/1.0/legalcode + +-------------------------------------------------------------------------------- + +The files in cpp/src/arrow/vendored/fast_float/ contain code from + +https://github.com/lemire/fast_float + +which is made available under the Apache License 2.0. + +-------------------------------------------------------------------------------- + +The file python/pyarrow/vendored/docscrape.py contains code from + +https://github.com/numpy/numpydoc/ + +which is made available under the BSD 2-clause license. + +-------------------------------------------------------------------------------- + +The file python/pyarrow/vendored/version.py contains code from + +https://github.com/pypa/packaging/ + +which is made available under both the Apache license v2.0 and the +BSD 2-clause license. + +-------------------------------------------------------------------------------- + +The files in cpp/src/arrow/vendored/pcg contain code from + +https://github.com/imneme/pcg-cpp + +and have the following copyright notice: + +Copyright 2014-2019 Melissa O'Neill , + and the PCG Project contributors. + +SPDX-License-Identifier: (Apache-2.0 OR MIT) + +Licensed under the Apache License, Version 2.0 (provided in +LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0) +or under the MIT license (provided in LICENSE-MIT.txt and at +http://opensource.org/licenses/MIT), at your option. This file may not +be copied, modified, or distributed except according to those terms. + +Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either +express or implied. See your chosen license for details. + +-------------------------------------------------------------------------------- +r/R/dplyr-count-tally.R (some portions) + +Some portions of this file are derived from code from + +https://github.com/tidyverse/dplyr/ + +which is made available under the MIT license + +Copyright (c) 2013-2019 RStudio and others. + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the “Software”), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +The file src/arrow/util/io_util.cc contains code from the CPython project +which is made available under the Python Software Foundation License Version 2. + +-------------------------------------------------------------------------------- + +3rdparty dependency opentelemetry-cpp is statically linked in certain binary +distributions. opentelemetry-cpp is made available under the Apache License 2.0. + +Copyright The OpenTelemetry Authors +SPDX-License-Identifier: Apache-2.0 + +-------------------------------------------------------------------------------- + +ci/conan/ is based on code from Conan Package and Dependency Manager. + +Copyright (c) 2019 Conan.io + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- + +3rdparty dependency UCX is redistributed as a dynamically linked shared +library in certain binary distributions. UCX has the following license: + +Copyright (c) 2014-2015 UT-Battelle, LLC. All rights reserved. +Copyright (C) 2014-2020 Mellanox Technologies Ltd. All rights reserved. +Copyright (C) 2014-2015 The University of Houston System. All rights reserved. +Copyright (C) 2015 The University of Tennessee and The University + of Tennessee Research Foundation. All rights reserved. +Copyright (C) 2016-2020 ARM Ltd. All rights reserved. +Copyright (c) 2016 Los Alamos National Security, LLC. All rights reserved. +Copyright (C) 2016-2020 Advanced Micro Devices, Inc. All rights reserved. +Copyright (C) 2019 UChicago Argonne, LLC. All rights reserved. +Copyright (c) 2018-2020 NVIDIA CORPORATION. All rights reserved. +Copyright (C) 2020 Huawei Technologies Co., Ltd. All rights reserved. +Copyright (C) 2016-2020 Stony Brook University. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. +3. Neither the name of the copyright holder nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- + +The file dev/tasks/r/github.packages.yml contains code from + +https://github.com/ursa-labs/arrow-r-nightly + +which is made available under the Apache License 2.0. + +-------------------------------------------------------------------------------- +.github/actions/sync-nightlies/action.yml (some portions) + +Some portions of this file are derived from code from + +https://github.com/JoshPiper/rsync-docker + +which is made available under the MIT license + +Copyright (c) 2020 Joshua Piper + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- +.github/actions/sync-nightlies/action.yml (some portions) + +Some portions of this file are derived from code from + +https://github.com/burnett01/rsync-deployments + +which is made available under the MIT license + +Copyright (c) 2019-2022 Contention +Copyright (c) 2019-2022 Burnett01 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +-------------------------------------------------------------------------------- +java/vector/src/main/java/org/apache/arrow/vector/util/IntObjectHashMap.java +java/vector/src/main/java/org/apache/arrow/vector/util/IntObjectMap.java + +These file are derived from code from Netty, which is made available under the +Apache License 2.0. diff --git a/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/METADATA b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..d729ad5cb4cdad3ae9155216d0c06a1535cc69e9 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/METADATA @@ -0,0 +1,86 @@ +Metadata-Version: 2.1 +Name: pyarrow +Version: 18.1.0 +Summary: Python library for Apache Arrow +Maintainer-email: Apache Arrow Developers +License: Apache Software License +Project-URL: Homepage, https://arrow.apache.org/ +Project-URL: Documentation, https://arrow.apache.org/docs/python +Project-URL: Repository, https://github.com/apache/arrow +Project-URL: Issues, https://github.com/apache/arrow/issues +Classifier: License :: OSI Approved :: Apache Software License +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Requires-Python: >=3.9 +Description-Content-Type: text/markdown +License-File: ../LICENSE.txt +License-File: ../NOTICE.txt +Provides-Extra: test +Requires-Dist: pytest ; extra == 'test' +Requires-Dist: hypothesis ; extra == 'test' +Requires-Dist: cffi ; extra == 'test' +Requires-Dist: pytz ; extra == 'test' +Requires-Dist: pandas ; extra == 'test' + + + +## Python library for Apache Arrow + +[![pypi](https://img.shields.io/pypi/v/pyarrow.svg)](https://pypi.org/project/pyarrow/) [![conda-forge](https://img.shields.io/conda/vn/conda-forge/pyarrow.svg)](https://anaconda.org/conda-forge/pyarrow) + +This library provides a Python API for functionality provided by the Arrow C++ +libraries, along with tools for Arrow integration and interoperability with +pandas, NumPy, and other software in the Python ecosystem. + +## Installing + +Across platforms, you can install a recent version of pyarrow with the conda +package manager: + +```shell +conda install pyarrow -c conda-forge +``` + +On Linux, macOS, and Windows, you can also install binary wheels from PyPI with +pip: + +```shell +pip install pyarrow +``` + +If you encounter any issues importing the pip wheels on Windows, you may need +to install the [Visual C++ Redistributable for Visual Studio 2015][6]. + +## Development + +See [Python Development][2] in the documentation subproject. + +### Building the documentation + +See [documentation build instructions][1] in the documentation subproject. + +[1]: https://github.com/apache/arrow/blob/main/docs/source/developers/documentation.rst +[2]: https://github.com/apache/arrow/blob/main/docs/source/developers/python.rst +[3]: https://github.com/pandas-dev/pandas +[5]: https://arrow.apache.org/docs/latest/python/benchmarks.html +[6]: https://www.microsoft.com/en-us/download/details.aspx?id=48145 diff --git a/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/NOTICE.txt b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/NOTICE.txt new file mode 100644 index 0000000000000000000000000000000000000000..2089c6fb20358ccf5e3a58ea27a234555b923f6b --- /dev/null +++ b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/NOTICE.txt @@ -0,0 +1,84 @@ +Apache Arrow +Copyright 2016-2024 The Apache Software Foundation + +This product includes software developed at +The Apache Software Foundation (http://www.apache.org/). + +This product includes software from the SFrame project (BSD, 3-clause). +* Copyright (C) 2015 Dato, Inc. +* Copyright (c) 2009 Carnegie Mellon University. + +This product includes software from the Feather project (Apache 2.0) +https://github.com/wesm/feather + +This product includes software from the DyND project (BSD 2-clause) +https://github.com/libdynd + +This product includes software from the LLVM project + * distributed under the University of Illinois Open Source + +This product includes software from the google-lint project + * Copyright (c) 2009 Google Inc. All rights reserved. + +This product includes software from the mman-win32 project + * Copyright https://code.google.com/p/mman-win32/ + * Licensed under the MIT License; + +This product includes software from the LevelDB project + * Copyright (c) 2011 The LevelDB Authors. All rights reserved. + * Use of this source code is governed by a BSD-style license that can be + * Moved from Kudu http://github.com/cloudera/kudu + +This product includes software from the CMake project + * Copyright 2001-2009 Kitware, Inc. + * Copyright 2012-2014 Continuum Analytics, Inc. + * All rights reserved. + +This product includes software from https://github.com/matthew-brett/multibuild (BSD 2-clause) + * Copyright (c) 2013-2016, Matt Terry and Matthew Brett; all rights reserved. + +This product includes software from the Ibis project (Apache 2.0) + * Copyright (c) 2015 Cloudera, Inc. + * https://github.com/cloudera/ibis + +This product includes software from Dremio (Apache 2.0) + * Copyright (C) 2017-2018 Dremio Corporation + * https://github.com/dremio/dremio-oss + +This product includes software from Google Guava (Apache 2.0) + * Copyright (C) 2007 The Guava Authors + * https://github.com/google/guava + +This product include software from CMake (BSD 3-Clause) + * CMake - Cross Platform Makefile Generator + * Copyright 2000-2019 Kitware, Inc. and Contributors + +The web site includes files generated by Jekyll. + +-------------------------------------------------------------------------------- + +This product includes code from Apache Kudu, which includes the following in +its NOTICE file: + + Apache Kudu + Copyright 2016 The Apache Software Foundation + + This product includes software developed at + The Apache Software Foundation (http://www.apache.org/). + + Portions of this software were developed at + Cloudera, Inc (http://www.cloudera.com/). + +-------------------------------------------------------------------------------- + +This product includes code from Apache ORC, which includes the following in +its NOTICE file: + + Apache ORC + Copyright 2013-2019 The Apache Software Foundation + + This product includes software developed by The Apache Software + Foundation (http://www.apache.org/). + + This product includes software developed by Hewlett-Packard: + (c) Copyright [2014-2015] Hewlett-Packard Development Company, L.P diff --git a/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/RECORD b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..03bf477b25344378880fd7c4da4c405405921638 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/RECORD @@ -0,0 +1,869 @@ +pyarrow-18.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +pyarrow-18.1.0.dist-info/LICENSE.txt,sha256=Ip2-KeThNE6VFy9vOkJ37A2lx4UMsDiXxH86JLevzgg,110423 +pyarrow-18.1.0.dist-info/METADATA,sha256=1khsr21oevo12MWgCroHP3HsH8tF1YBunmiHf0S3RLE,3292 +pyarrow-18.1.0.dist-info/NOTICE.txt,sha256=ti6iQmQtOhjx4psMH-CCQVppQ_4VjuIrSM_zdi81QAk,3032 +pyarrow-18.1.0.dist-info/RECORD,, +pyarrow-18.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +pyarrow-18.1.0.dist-info/WHEEL,sha256=7fIOuxOvQdM3WcnNr5qDe310YKFXhPxz6MdvYC4bKQg,113 +pyarrow-18.1.0.dist-info/top_level.txt,sha256=Zuk_c1WeinXdMz20fXlEtGC67zfKOWuwU8adpEEU_nI,18 +pyarrow/__init__.pxd,sha256=Wnar1phFqM_ZHnZmtbuqm6wJHsXlBoYKhV7Qmo2jUHA,2195 +pyarrow/__init__.py,sha256=KdUkzmN0NJf1AKTskHDoH3OwZoc0Ih2PRu3BqtdjHbY,18119 +pyarrow/__pycache__/__init__.cpython-310.pyc,, +pyarrow/__pycache__/_compute_docstrings.cpython-310.pyc,, +pyarrow/__pycache__/_generated_version.cpython-310.pyc,, +pyarrow/__pycache__/acero.cpython-310.pyc,, +pyarrow/__pycache__/benchmark.cpython-310.pyc,, +pyarrow/__pycache__/cffi.cpython-310.pyc,, +pyarrow/__pycache__/compute.cpython-310.pyc,, +pyarrow/__pycache__/conftest.cpython-310.pyc,, +pyarrow/__pycache__/csv.cpython-310.pyc,, +pyarrow/__pycache__/cuda.cpython-310.pyc,, +pyarrow/__pycache__/dataset.cpython-310.pyc,, +pyarrow/__pycache__/feather.cpython-310.pyc,, +pyarrow/__pycache__/flight.cpython-310.pyc,, +pyarrow/__pycache__/fs.cpython-310.pyc,, +pyarrow/__pycache__/ipc.cpython-310.pyc,, +pyarrow/__pycache__/json.cpython-310.pyc,, +pyarrow/__pycache__/jvm.cpython-310.pyc,, +pyarrow/__pycache__/orc.cpython-310.pyc,, +pyarrow/__pycache__/pandas_compat.cpython-310.pyc,, +pyarrow/__pycache__/substrait.cpython-310.pyc,, +pyarrow/__pycache__/types.cpython-310.pyc,, +pyarrow/__pycache__/util.cpython-310.pyc,, +pyarrow/_acero.cpython-310-x86_64-linux-gnu.so,sha256=D6iY-glDm1DB8xa8NsBsYPuyUmm2U96B8BBmM58YnqA,322128 +pyarrow/_acero.pxd,sha256=5ish_GgGWvit4ebhzoZil7b-m0r2RuG5JwYoxsH34FI,1440 +pyarrow/_acero.pyx,sha256=56orFsG2ksoP4C0DPIa-ruQxQRCC489lYlHkGJIh1zY,21301 +pyarrow/_azurefs.cpython-310-x86_64-linux-gnu.so,sha256=-RqxGkmw7ActEwAJhX-uv_adBEa1m4nlGQuNJ1cA8Lw,106712 +pyarrow/_azurefs.pyx,sha256=ezGU_z3kIw2r14YAB4yogaxMssJXikcxajz4dZSez1k,5909 +pyarrow/_compute.cpython-310-x86_64-linux-gnu.so,sha256=e__gjV8MtvwaOGONewMYqK0sDB7jvKHklLT_a3eOVPQ,1342256 +pyarrow/_compute.pxd,sha256=nmjgwV2KCGFfxZj5ruDwM4oH1ITqF0rDQS0yDvcaXBA,1949 +pyarrow/_compute.pyx,sha256=dmGXzWOdzMfrj-nWV8RWBRypswmtKZSEwRZ64KZsuuY,107233 +pyarrow/_compute_docstrings.py,sha256=7Vg8jt1aCsWrpTxsdqR7gY6M0faxXNX31c1RZdq9CFw,1707 +pyarrow/_csv.cpython-310-x86_64-linux-gnu.so,sha256=uvnXZK4MCxL3ZBJHgeOz4gbouEuSUu67lhCdR2PbLAc,362872 +pyarrow/_csv.pxd,sha256=1Zk3Zpvvhy-Tb7c79Aqd4e7bBM21kc1JxWJkl02Y4DE,1638 +pyarrow/_csv.pyx,sha256=aqWLHgfZ-nrqKHfVVVXeGbtY2ZChE6Oi9qIa5jP4m1M,54705 +pyarrow/_cuda.pxd,sha256=VzhM6j9dpNgrABlvFJKoMpRC0As55im-M3tgPTOuwEk,1922 +pyarrow/_cuda.pyx,sha256=YSlswn4Tj1H24SL_iPIGqT3v3JmofE7NwCunuOLMNwY,35136 +pyarrow/_dataset.cpython-310-x86_64-linux-gnu.so,sha256=egE_LwvobAb1TfFH72xoIYMP1GpgrQFlhVTDj68b_Z4,1094224 +pyarrow/_dataset.pxd,sha256=Ag9rUhoBySU6ba3wFLeuZyWMJnz9VkAf9TQEzWG4hUU,4944 +pyarrow/_dataset.pyx,sha256=WGqJ4LCtbpxkU4bdIjLR0MAxE1WgmrsCvSQlr1M-emc,157400 +pyarrow/_dataset_orc.cpython-310-x86_64-linux-gnu.so,sha256=tAsLU3DeAQt5PAZGwds06m1qsj1igJXPLj8RdBVVM_E,79976 +pyarrow/_dataset_orc.pyx,sha256=JSFoRI0pfHtL2jeIuPg5TJHodcfuCNYmj_iEZ4xY87w,1499 +pyarrow/_dataset_parquet.cpython-310-x86_64-linux-gnu.so,sha256=ww5q51ZT42pTZUBdKIBWMGtVe2z-cF3J1gWlAQtzFGo,369784 +pyarrow/_dataset_parquet.pxd,sha256=y-3iKehyB_eB_oeqjtt4aQRbUpVGVN1oUMFGIY13brE,1572 +pyarrow/_dataset_parquet.pyx,sha256=x_VvTpuF9vxfAAUGkLZrr0N_TCxYWlqMahlkg0201gQ,38916 +pyarrow/_dataset_parquet_encryption.cpython-310-x86_64-linux-gnu.so,sha256=en-S0rae1pJMl9V3oN61ogVhIgL_TTBUgodRVcLpQpw,122184 +pyarrow/_dataset_parquet_encryption.pyx,sha256=p7LDNUsp3jMVcWDcbOFp8a3CYJjASVPI_tfATpY-ePg,7229 +pyarrow/_dlpack.pxi,sha256=clw0FkGoyZMEtUU8zPpO_DMtl2X-27kb2UtyhQuIc1s,1832 +pyarrow/_feather.cpython-310-x86_64-linux-gnu.so,sha256=JoPucTYih0LuZCIVP5yHcK-rHyK52ccqaTNbUwlIMac,115720 +pyarrow/_feather.pyx,sha256=DWQI4U0uAWE1ZYUwPreBPJg1TGLEGmF3wPEIRL-PhPw,3773 +pyarrow/_flight.cpython-310-x86_64-linux-gnu.so,sha256=w3WJ0MVAFBvO0CnykCB2v8lyTWDH4LvOo0bXXXohHCI,1303088 +pyarrow/_flight.pyx,sha256=siQR9YhOPLToP5dnHtkm-aCjgPfBLYq8d777RHY_MsY,110592 +pyarrow/_fs.cpython-310-x86_64-linux-gnu.so,sha256=c8AkO080ASb-CGM33P7OhBxg_ZOC_KMC8H9S6qfIKfo,501392 +pyarrow/_fs.pxd,sha256=SmHS31eyYU7VUZlVuP613HKgpd7bENnQGApvX_g2Lfw,2439 +pyarrow/_fs.pyx,sha256=ZyfvmWary8XTHaCoeSYtjI-b0SK0lCsznerI8cGh4K8,52479 +pyarrow/_gcsfs.cpython-310-x86_64-linux-gnu.so,sha256=5ZnCwP2s6YRBVhYgQRIpCBUdrhSddDpFxlLxHNf8Reo,133464 +pyarrow/_gcsfs.pyx,sha256=fa1QmTQII9sFKtjtfeZPQfTEntAh3IGyJJ1w116OCA4,9121 +pyarrow/_generated_version.py,sha256=Soy0A65IyGohu8QOyRrzPypaVt4qqH1YV1839Jm0jc4,413 +pyarrow/_hdfs.cpython-310-x86_64-linux-gnu.so,sha256=_h9d5UJWboLCd8jYSTNsPDhv28p0jSzfEFEhjvhWK0o,131816 +pyarrow/_hdfs.pyx,sha256=HA0KkZa6aVRmwg3ku3U7lZo_8COn1cLwylfc6nEJUlg,5885 +pyarrow/_json.cpython-310-x86_64-linux-gnu.so,sha256=f7OC28PFHUB0yUfn0dvg4_7QK4AKtea5-qtgeTx3alo,113560 +pyarrow/_json.pxd,sha256=tECTP14M12-b_ja5QI3snQbd0uWPWmmC9FwkWq23Vg0,1206 +pyarrow/_json.pyx,sha256=RmaWaSTG61u2Qcmc_fLsTns_awLJDls3_SdlaCAg53Y,9860 +pyarrow/_orc.cpython-310-x86_64-linux-gnu.so,sha256=QFQ-yqAc-WoNu2qyXzQ-JXYDNITWhvr9GCiGo_I8Rcc,209752 +pyarrow/_orc.pxd,sha256=6hL0cq1RufqQD-B_bV3ne1rhu2g-h4rDOFNQsSb6qps,5689 +pyarrow/_orc.pyx,sha256=Pn7r4dzagWaqMf8rymbXBIWisxonBaStZgXCi7pfrZI,15556 +pyarrow/_parquet.cpython-310-x86_64-linux-gnu.so,sha256=leDrWcYTHBwxHvUh-ZaC5rhbKdkjdiGdSAan-VmLHJs,605832 +pyarrow/_parquet.pxd,sha256=bLdSgSZg1bn-ZsQbAKOWH44esooFHQOiO9wqmrQuvn4,26805 +pyarrow/_parquet.pyx,sha256=xpIBXt3xv9S1H9G6CqSpwl_ZokhJpy09yShxuntqMMg,74388 +pyarrow/_parquet_encryption.cpython-310-x86_64-linux-gnu.so,sha256=XFQ5qIp5TUFehTAYb2F9isPded66aimtmB2RcQzvWOY,285904 +pyarrow/_parquet_encryption.pxd,sha256=1vQnkyS1rLrSNMlmuW62PxkOmCsYpzC60L9mqD0_LYc,2586 +pyarrow/_parquet_encryption.pyx,sha256=CaTiq5EjTVGYQnxDEmpYcItSBiEencV-pNEu-lBAiOk,18625 +pyarrow/_pyarrow_cpp_tests.cpython-310-x86_64-linux-gnu.so,sha256=4ViC5QmmboDg6yqrchIY6aMruundIDy2J0Ljc0tVJT8,85576 +pyarrow/_pyarrow_cpp_tests.pxd,sha256=nPyRmNtFbOUvSXCwegAApQFfh8UI_K9Hq5dN4oPAxdo,1199 +pyarrow/_pyarrow_cpp_tests.pyx,sha256=gLeMzB9RWodZgXEpipX65_0aqWu12SjMld0JZmZVRP0,1753 +pyarrow/_s3fs.cpython-310-x86_64-linux-gnu.so,sha256=FdhXZkHk2JNBmTEwJkmL3sZf0NM1BADH1BKKBx0PZGM,232056 +pyarrow/_s3fs.pyx,sha256=VFuZkBV8rt44JrYtAwbPxGI1YlZJ9gfl1U91JQgJEMU,19706 +pyarrow/_substrait.cpython-310-x86_64-linux-gnu.so,sha256=IORBlN5-tj2oWziFNT4rNq37BXN_dPMu1xFJWNCcQGo,190624 +pyarrow/_substrait.pyx,sha256=CA2kxzxJUVPL7lMn8_XSAa9jt1Alq4IbhcI3sHGvsxw,11630 +pyarrow/acero.py,sha256=_P7DcFTmhgW4-EAyM67luFMWcp4t1iUX1pKBIkVe7cM,15108 +pyarrow/array.pxi,sha256=jP6v7Y3YUVggdyKmfNAa7hGNd2T-1xONCTxK-2a-IOI,151046 +pyarrow/benchmark.pxi,sha256=DYXdu-jMSH7XcTohbc8x8NiKRLtpX9IULfY20ohkffA,869 +pyarrow/benchmark.py,sha256=k9Z3yQyoojpYz4lTA6DkCfqT6fPG3N2fJtsHKjpbYFo,856 +pyarrow/builder.pxi,sha256=9QE4KAiA4JpA7-2JLgX3xo32jRtuWZ3YqC-T9GzUVDc,4634 +pyarrow/cffi.py,sha256=hEcrPH9KeG6NES3ZCpSbOVYhOgDOuBB_2LgMMucgw-8,2396 +pyarrow/compat.pxi,sha256=Sq5c3CKq0uj5aDyOoHHkPEO_VsSpZ90JRaL2rAKHk5I,1920 +pyarrow/compute.py,sha256=MyrZk7PTX-8pYlUu5PLbuXjDMTRpyCcgdFWi2BPVK0I,23181 +pyarrow/config.pxi,sha256=E6QOFjdlw3H1a5BOAevYNJJEmmm6FblfaaeyspnWBWw,3092 +pyarrow/conftest.py,sha256=afosSyVsVRsJdDXRXOFQEyj4qVO39OtZYVb_wbvvadU,9811 +pyarrow/csv.py,sha256=S6tm31Bra9HPf9IsYwBLltZBLMvNzypWfeCLySsjmds,974 +pyarrow/cuda.py,sha256=j--8HcBAm5Ib-kbhK4d2M6SVQmDWkr7Mt5fnwU2LzdQ,1087 +pyarrow/dataset.py,sha256=4ibGh9x36jEYI7VMxTdZc-XDg8VfNx6RPbA2L-bLJbA,40232 +pyarrow/device.pxi,sha256=CtVBXp68zNXrrPwehh56igfLsMSlYRo5rWFcKkEP_gY,5569 +pyarrow/error.pxi,sha256=Wj7-NGUfdvlEwAwd8Ta_JqRC8IUOUpm_PmpvizCFvfY,8909 +pyarrow/feather.py,sha256=9rWL-TYK_qc0FW3vIyYyd6Xt86ApJWLqo-2cK3F5vGQ,9959 +pyarrow/flight.py,sha256=HLB04A0SZ35MZJumPIuBu5I2dpetjEc-CGMEdjQeQRQ,2177 +pyarrow/fs.py,sha256=M-cSbS2bBR4MwbJqpz9Q7VxHY8fa89StEw2J0XMMF7E,14899 +pyarrow/gandiva.pyx,sha256=bF23rkq6e45i-CePDZeTy9iFwoeg8ElrNjz9VK97QRs,24503 +pyarrow/include/arrow/acero/accumulation_queue.h,sha256=_HoTuKEkZodmrwXF9CeWGsmpT7jIM0FrrYZSPMTMMr8,5856 +pyarrow/include/arrow/acero/aggregate_node.h,sha256=9HdFxR6tzSfx_UaUHZtS1I2FCbm3PvfF8FdekVpBO34,2155 +pyarrow/include/arrow/acero/api.h,sha256=fRuKEHbKDYWRCwSHLc7vSD-6mQavyOsztluCR7evFCk,1151 +pyarrow/include/arrow/acero/asof_join_node.h,sha256=Ko6r1wDjxg01FE9-xKkttx7WzCAzf43GxbpvGHgKZp8,1490 +pyarrow/include/arrow/acero/backpressure_handler.h,sha256=CsSWRenrtbZYiNnf-cdYCgMLmu5KUAPUKNKMDWttoD4,2810 +pyarrow/include/arrow/acero/benchmark_util.h,sha256=T5bNabF1TDAp28S7V_vt_VIDn6l5Be0zOVCHhcTcFf8,1943 +pyarrow/include/arrow/acero/bloom_filter.h,sha256=bFzzAzQrs9ePp2tCPQIuk1Oa9gG_Nyp72M_HM0dhakM,11978 +pyarrow/include/arrow/acero/exec_plan.h,sha256=U0KA3tnNvVb75G0XQFLVbGzXCGdddGyRhW3zMa8oWJc,35909 +pyarrow/include/arrow/acero/hash_join.h,sha256=Ji0k5z778QtNQ0MwU6xBP6z7ajLk79Va-vgCqrlApso,3003 +pyarrow/include/arrow/acero/hash_join_dict.h,sha256=_BKJmK3Z_KdJuYHh4KQCuT_1rXlUohrtEgGLtEJ4fgQ,15360 +pyarrow/include/arrow/acero/hash_join_node.h,sha256=FXT-aeXL7nNTuV75f9oXgdGyqMK_72GnqGUm9cmBnko,4378 +pyarrow/include/arrow/acero/map_node.h,sha256=Bd1HcW0N5azoIVth2ATeHxgTKd9XmmEkz42YBNw5eK0,2628 +pyarrow/include/arrow/acero/options.h,sha256=r-GnLElNJAAdFoJ7k0Q1TOfvGSOdgT9BrWbdMcS_SF0,37262 +pyarrow/include/arrow/acero/order_by_impl.h,sha256=dQqplP-AZWPZRKio8LmTjYWlCYz9VmW-usUrtaLpd_w,1691 +pyarrow/include/arrow/acero/partition_util.h,sha256=bs_zxok-qng8jsHmVBlfJ7Ts2uBEmovEb27knqQmT-Q,7411 +pyarrow/include/arrow/acero/pch.h,sha256=8VXXI10rUHzlQiAthx-yjHMQCpGL3dgAiVaGzTubPPE,1094 +pyarrow/include/arrow/acero/query_context.h,sha256=D364aGRS3uWe8lgYqCNRjVvs5sKetLOOXzACdp5GZeg,6212 +pyarrow/include/arrow/acero/schema_util.h,sha256=KA_hV2xy2TRccMyksSzQrdH9_rdGo3tQyHOIvrWWYBQ,7961 +pyarrow/include/arrow/acero/task_util.h,sha256=6pqILuYfcVwt9HqVhRfXFVJoOC-Q_dtk8mQ5SxjgwbY,3706 +pyarrow/include/arrow/acero/test_nodes.h,sha256=xKeLWZZC8iokveVXPjseO1MOvWMcby-0xiMISy0qw8E,2877 +pyarrow/include/arrow/acero/time_series_util.h,sha256=W9yzoaTGkB2jtYm8w2CYknSw1EjMbsdTfmEuuL2zMtk,1210 +pyarrow/include/arrow/acero/tpch_node.h,sha256=l3zocxHTfGmXTjywJxwoXCIk9tjzURgWdYKSgSk8DAQ,2671 +pyarrow/include/arrow/acero/type_fwd.h,sha256=4zLhtLJf_7MSXgrhQIZVGeLxjT7JrEDAn9yW75DTFlc,1103 +pyarrow/include/arrow/acero/util.h,sha256=byhMEj5XoAUy-93AjLrx_p9_iUZdYn5uJ_cDkCJQt5Q,6121 +pyarrow/include/arrow/acero/visibility.h,sha256=E-4G2O4F2YabXnFNJYnsI2VbVoKBtO7AXqh_SPuJi6k,1616 +pyarrow/include/arrow/adapters/orc/adapter.h,sha256=G5SSGGYMSREILC43kqL5fqo94c4tKgukitO15m217tY,11031 +pyarrow/include/arrow/adapters/orc/options.h,sha256=FMxda5YSskRrB6h9FvcAuMxl5qdavWrNYHPlanjtk48,3696 +pyarrow/include/arrow/adapters/tensorflow/convert.h,sha256=ZGFAodnwTJK0ZoXfgYJdjgi_F4vfEhI9E87zejxVb6E,3465 +pyarrow/include/arrow/api.h,sha256=Gs6HiRBYU5N7-a79hjTl9WMSda551XdUKpWthFY2v1s,2491 +pyarrow/include/arrow/array.h,sha256=P5oW6hvD2j97bLaSTE4_UHuV6Y38DTwJVww3Eb3xdTQ,1981 +pyarrow/include/arrow/array/array_base.h,sha256=14RULo7wEJze9IY2psySGtBlBsnCErnqY4lBO4ckU6g,12123 +pyarrow/include/arrow/array/array_binary.h,sha256=JvtB8DoR0_tqfSFS_9nMRrJ39lt1cTm5yXh-DLkhqjU,11247 +pyarrow/include/arrow/array/array_decimal.h,sha256=xRfrZ1IFO09EmkHEolCwrJ4lsXjLo5DXdfH5_v2gSyw,3105 +pyarrow/include/arrow/array/array_dict.h,sha256=6AMbSnZoMj-nhQhZhG4RNnxy9VVPk2DvZjVblwIUhgY,7611 +pyarrow/include/arrow/array/array_nested.h,sha256=xySiF5b1ab97GifKMx6FuYZWb2_6e3YvSMfOORGe3J4,37605 +pyarrow/include/arrow/array/array_primitive.h,sha256=anek7WkjubNBTRz8wOHyZ0_UuE3BExj02P-PCs3F5To,7719 +pyarrow/include/arrow/array/array_run_end.h,sha256=4zs3tcUrIgDOhSEOywJ1vGY2lsH-5QuEBn87mxnDbi8,5101 +pyarrow/include/arrow/array/builder_adaptive.h,sha256=92DpiIZDXSI_yOrMftj7P60zlCLjNmwfGM5ubdbXWM4,6861 +pyarrow/include/arrow/array/builder_base.h,sha256=CP9kS8pDFd4XyJQdgIlBp3pTIX9mND1Lvh85re4IC8w,13723 +pyarrow/include/arrow/array/builder_binary.h,sha256=01BrSwkFQNAEy4FVYi8Esbd2CaeyxN04GDUoXsQUFhU,32718 +pyarrow/include/arrow/array/builder_decimal.h,sha256=DFxyFlpzWRZS9zdBhsjII5fFUOMY9bXHn3EIrIvmOMo,5051 +pyarrow/include/arrow/array/builder_dict.h,sha256=FZjvCRIDmVuwmzx_HCcDK6ZjNoZKCEsSV-fGI0K974Y,27899 +pyarrow/include/arrow/array/builder_nested.h,sha256=O8r6v9n2l9dUFmRPtm1WuP0zFAewzSeoosLmfACB1kA,31270 +pyarrow/include/arrow/array/builder_primitive.h,sha256=OOfGI-zDM7BMWIBv-Tko_8pJDkpw-ttQM76JldlUOvc,20808 +pyarrow/include/arrow/array/builder_run_end.h,sha256=SZIdsUKK1qAc9pdonPGf0A_aikZHcxxzicezRGR5hLs,11416 +pyarrow/include/arrow/array/builder_time.h,sha256=8M2ifZnDgujSItXKsevyBdtM6Iky3ImyeIdAqZV3fec,2548 +pyarrow/include/arrow/array/builder_union.h,sha256=8BF532sAMc7JxWIbSN-yX6Z9fqY9jmmsIa054DPvbWE,10144 +pyarrow/include/arrow/array/concatenate.h,sha256=wBy-CBTz9MeRCmcnfXGvkXnvSRApvPOcfCf64A42ys8,2059 +pyarrow/include/arrow/array/data.h,sha256=BuYmkq11BUas2FvufTRZkg_aoWVd-rLX1sBQIwB5HuE,25147 +pyarrow/include/arrow/array/diff.h,sha256=bYNKy2oLAxtt6VYDWvCfq2bnJTVNjG5KMTsGl-gT_kM,3344 +pyarrow/include/arrow/array/statistics.h,sha256=JYPb5hAHmJTQ9cDHcEhhHGRBZurt6CcVbUOlp54UWSU,2498 +pyarrow/include/arrow/array/util.h,sha256=qVHvCaVlALz8WJwAjyMwsBm5J2iN89CSgj7NpmmqlkI,3652 +pyarrow/include/arrow/array/validate.h,sha256=JdDb3XJg4TmAfpv_zgu2ITfL2H9no10TQit-HPj9Myw,1710 +pyarrow/include/arrow/buffer.h,sha256=EfXDyFegRdva4rv4nf0jtErnIrt9_FWoXSHk6OPk_G8,23092 +pyarrow/include/arrow/buffer_builder.h,sha256=tXWILwHW0MKpve7NIU2ElElPY0y0ooISa82Dq6UdhVU,17371 +pyarrow/include/arrow/builder.h,sha256=mBxMko271lJ7Xbku0hCixj943Yx-d2i4Q5Hm2WfwiGM,1546 +pyarrow/include/arrow/c/abi.h,sha256=ZohWkqHoTBeIIGYs2iv2VLL8I4G5lP8MAWgbtpWKLVM,7917 +pyarrow/include/arrow/c/bridge.h,sha256=D9W-vKI_Ko6_INcMAdUx15foV08UbBvL48R8RRcL5cM,18132 +pyarrow/include/arrow/c/dlpack.h,sha256=_HIa9AKR2mwbhf1aChIpMF_XDpFrPaf58Lt3fVxWRWc,1817 +pyarrow/include/arrow/c/dlpack_abi.h,sha256=mjp9WWq8qv6gkGirT4y0o3BL_ZI9VyHQpJ5aEpPFetI,9920 +pyarrow/include/arrow/c/helpers.h,sha256=f0Q519PwoliFHpxsHp-QvbP6fpVMN2Ha35Tk-RBK6Ws,6279 +pyarrow/include/arrow/chunk_resolver.h,sha256=lR4Drywh_3K32dDm0LYDQLp6AeQx7cswspVjmgzgsns,12519 +pyarrow/include/arrow/chunked_array.h,sha256=z6LA9OB3uhtmn7ZZe5wfi3Am3icVQ-L_e8s3KEMuq18,10647 +pyarrow/include/arrow/compare.h,sha256=U5craXnXACCUzQ8HmGYyhTehNrOezcVUP1ABAlxI62E,5555 +pyarrow/include/arrow/compute/api.h,sha256=IQKXz_6YBBfHKOkuqkXIh9ZTZYyVgq7aEBTIzMkZEiI,2071 +pyarrow/include/arrow/compute/api_aggregate.h,sha256=cgXomjDDHoAK_ddzyH1NSqWAewzEYPD7qJBj4x5Rkhk,17173 +pyarrow/include/arrow/compute/api_scalar.h,sha256=xtRsJg11WgE5RXV9gZZHfhlEElLEpWUUWnbZXTKw4j8,66540 +pyarrow/include/arrow/compute/api_vector.h,sha256=6jxDvg_Zz14_63SfVlWnfUff135kls1aGGK_d9h3bj8,29122 +pyarrow/include/arrow/compute/cast.h,sha256=Xw9j03AIAMU_hZiqk9d2ZD4xTmESkfXaDsuZkiTypLs,4245 +pyarrow/include/arrow/compute/exec.h,sha256=0ZAA9_tzcQEr364sjJ3SwgTtURTwtCjRLzo_LOdn960,17969 +pyarrow/include/arrow/compute/expression.h,sha256=llX_81uUIyJ8vPmP8-2mAippyw4cVNhCGfqHRY37FOM,11184 +pyarrow/include/arrow/compute/function.h,sha256=krTXaLowvT1cKhecs70urPQcx74vQCJ4jswtBE4Xs5A,16345 +pyarrow/include/arrow/compute/function_options.h,sha256=Q9rjkXPrU9-Xi64_fMLPbBbW_byhjJFsvHppP1CumdA,3088 +pyarrow/include/arrow/compute/kernel.h,sha256=ywsxF87w2eI4li8be7Wiua5bXp0NYhMb7LS8IzPFO3U,31406 +pyarrow/include/arrow/compute/ordering.h,sha256=8Vw3VzDi1mGgVwKGQZakz9TVj0A40wxcL13EvuqNVjU,4129 +pyarrow/include/arrow/compute/registry.h,sha256=x7LHiaNEVvZ0VUssZFsasB52Z1AxRflkdI5tR1hhzqc,4837 +pyarrow/include/arrow/compute/row/grouper.h,sha256=m-XUADUbpC2wSYmea8rFMbooh0gJQtdTBoF81ywhhjY,7319 +pyarrow/include/arrow/compute/type_fwd.h,sha256=-O63QUbsxWws8TBi55x6u9FweUSSOOfizhE4pTczLd4,1537 +pyarrow/include/arrow/compute/util.h,sha256=eF_BX2aftTa3qUJwaZA3QGTajrDv4nf6HKXs6dOmjug,8863 +pyarrow/include/arrow/config.h,sha256=8liyKI0CJO0G-Fz5I--QjIAwh0m4hosfyAOwvVVs0sU,3044 +pyarrow/include/arrow/csv/api.h,sha256=LbwWhPyIsi_73hvsSr77RNR9uUxrVyXM__hp7QcSom0,907 +pyarrow/include/arrow/csv/chunker.h,sha256=nTs8hdy4D3Nz3oZWm2JMuA02noY_0pWRYWq_RptqzHY,1171 +pyarrow/include/arrow/csv/column_builder.h,sha256=7oa9YCg2Uc2mB7ExHIyYIvbdt555qLXiU0y4FepkISU,2890 +pyarrow/include/arrow/csv/column_decoder.h,sha256=10idcPJE2V_TbvgjzPqmFy1dd_qSGWvu9eDkenTuCz0,2358 +pyarrow/include/arrow/csv/converter.h,sha256=cjtnz_hZFxm_dWjAMjr1iqqk1egXI2Yb8Bd0xC8md5E,2789 +pyarrow/include/arrow/csv/invalid_row.h,sha256=gTHjEbjkpee6syLGA8hFY7spx1ROMJmtMcwhXv21x5Q,1889 +pyarrow/include/arrow/csv/options.h,sha256=_HkjSoiAPW77z5AHVVnTa452y1KfJgnXWXz2NoPPAYw,7980 +pyarrow/include/arrow/csv/parser.h,sha256=8PplRh3Qxckk8VPyM70P_f1MBb4WMGnNVpoeJ9kOdHU,8616 +pyarrow/include/arrow/csv/reader.h,sha256=416pt3yNQsgn4RhIyRMsmSJmvv1sw3ouQotubXG91gQ,4606 +pyarrow/include/arrow/csv/test_common.h,sha256=uEYzw8EROvd1QMBQ98d4MaZ7BqMlw2e0flAyz-du0Z4,1972 +pyarrow/include/arrow/csv/type_fwd.h,sha256=ptVbengmY_a7Yz1w0SKmKL16yyw9yEeym0Q0cnRCSV4,984 +pyarrow/include/arrow/csv/writer.h,sha256=Y1zErZ5H1r2QzjAta3TXpFrdl2btoardCF8USCAGtGg,3549 +pyarrow/include/arrow/dataset/api.h,sha256=p7i-bncJLhmfBkfjJWS7684vD9Lke1m6tb7HQq7Tpn4,1322 +pyarrow/include/arrow/dataset/dataset.h,sha256=sDkJg42vSE05FwRmYi9pes3jD9932X3J8cyYZ3SY2jI,19830 +pyarrow/include/arrow/dataset/dataset_writer.h,sha256=TQV75b_UigfGjIpBnPk8teOncM5WroKfKV15oicBRRY,4589 +pyarrow/include/arrow/dataset/discovery.h,sha256=x7-5NBAyEeQWGlWanJDLZAoWksKiMwM96tlDx_M6n5c,11236 +pyarrow/include/arrow/dataset/file_base.h,sha256=2oe5v8Qy6v_UthJavg9rjU_WuQvwXcJengWwc3sWLqk,20203 +pyarrow/include/arrow/dataset/file_csv.h,sha256=7PlvQW_2FJ5RRN-VH4-OBw5cZ6nkd0KE0sj1TQvCZeo,5016 +pyarrow/include/arrow/dataset/file_ipc.h,sha256=6-btvXhflZsAH90T3wMkwzZkte6T4ixzeCEUn_5uYW8,4083 +pyarrow/include/arrow/dataset/file_json.h,sha256=sPjOeMOtbZZbvOivnOdb4MvYKHltpTnY8fONkhB9PZs,3523 +pyarrow/include/arrow/dataset/file_orc.h,sha256=P7nAD9nacVngDEjH8ChQRt0AQmDg4Z1wBx360LDOoSg,2452 +pyarrow/include/arrow/dataset/file_parquet.h,sha256=bzArl0XrmtTNvWhs6YTkLFxtD8TLbTIJwYmWz3YRm38,16708 +pyarrow/include/arrow/dataset/parquet_encryption_config.h,sha256=Upo0k5MijZaMaRZjPp5Xg8TRt1p8Zwh2c2tdimjVe1A,3425 +pyarrow/include/arrow/dataset/partition.h,sha256=3wrNekD_-fPO1YW91Za-T4muCfQeAX7SZRIcsCN_czI,16815 +pyarrow/include/arrow/dataset/pch.h,sha256=iAE_PbVtKHfhygz7Ox9Z2nlhsIrfageGixGKjlzNRvg,1194 +pyarrow/include/arrow/dataset/plan.h,sha256=IjuR9K2sWD85_2HpVVoJ-3YUCq--UPblHU46exX5qRg,1181 +pyarrow/include/arrow/dataset/projector.h,sha256=KfZijq09Ht0Z2cJHsrjg-sE3SiZ4TKainflReK-39cg,1135 +pyarrow/include/arrow/dataset/scanner.h,sha256=9Ats-ejc6exp3alGUhq0Sw8fww3kJj4ssi8FOKK7SDk,24598 +pyarrow/include/arrow/dataset/type_fwd.h,sha256=YOUSRwdNAlXJ7meFLolpAFQ_mSlObs2F81zcOy0DoI4,3170 +pyarrow/include/arrow/dataset/visibility.h,sha256=ckmf_sEI0WBo4W7DIgH1QrOq82skOHtoksl9B3yYvzU,1586 +pyarrow/include/arrow/datum.h,sha256=XYaZ_URrAtVqHMq-_2YtXk_ETeQ4yZWLVAnsi-k2Mac,11511 +pyarrow/include/arrow/device.h,sha256=mLz99tb74VdjxXtKt6RZCYKJQ8TYz93uaCFJ1ZiItMw,15344 +pyarrow/include/arrow/device_allocation_type_set.h,sha256=ynoZ-XyFlOAjh01PU-R11mE_EOxuw3xzc94v5OXa0u4,3306 +pyarrow/include/arrow/engine/api.h,sha256=ORM0M5KQeurjEG8Eoa5IeV_ZgKBRPlWyicyv3ORWkAY,886 +pyarrow/include/arrow/engine/pch.h,sha256=8VXXI10rUHzlQiAthx-yjHMQCpGL3dgAiVaGzTubPPE,1094 +pyarrow/include/arrow/engine/substrait/api.h,sha256=W9NB1RAm0ZVxztRXYA-GD7H8XLQNXFoYT7TdGFHoNTE,1079 +pyarrow/include/arrow/engine/substrait/extension_set.h,sha256=FE6cceycuQv7CCe_Fl4t6tIMRyfoJfWClUhSvHgcm90,21552 +pyarrow/include/arrow/engine/substrait/extension_types.h,sha256=x5ZIuynNh6WFt3wRjW--zUsuC3SeDLk1qRg9_xhswWM,3075 +pyarrow/include/arrow/engine/substrait/options.h,sha256=dtvUty_zoDmcFwVflppiDzelYkeOhCO74uRF6izQSzk,5820 +pyarrow/include/arrow/engine/substrait/relation.h,sha256=V3VKFlDdE61e1OS8LbJiwvm5w0uq5bzBLhKqmgmKaws,2385 +pyarrow/include/arrow/engine/substrait/serde.h,sha256=mjxfuFo4aPhCiwefpKAJMIlknF4UOHSr6gWU__1SwCc,16528 +pyarrow/include/arrow/engine/substrait/test_plan_builder.h,sha256=REFa79D1AOIIjp2Iez73iw5gEnzG9Rac9t8WwiGLsuI,3003 +pyarrow/include/arrow/engine/substrait/test_util.h,sha256=IHZeYrk50Sx9anJfC25DWP6XesItKEywDWUqvUJcjEQ,1517 +pyarrow/include/arrow/engine/substrait/type_fwd.h,sha256=P9YRjAQpSgoIjDC0siYyxoQzcPVo3r9y85qjiMtudBs,1028 +pyarrow/include/arrow/engine/substrait/util.h,sha256=_dRiQBaIMWNbsYG7kuXhs3dMk4dI63-pM0uSxYPOvgE,3570 +pyarrow/include/arrow/engine/substrait/visibility.h,sha256=GRzH6U-UCPT8d60cywOkFfcanPSgiZKCDP6X2rIpbMs,1740 +pyarrow/include/arrow/extension/bool8.h,sha256=VsHTtVyrqk6UKgvifad7LouuieoAZuZs_uVvegdGq4Q,2145 +pyarrow/include/arrow/extension/fixed_shape_tensor.h,sha256=VOqvTSnwDIvnhbstYX5nnqWfhtZ7MaD-lSF89BEqlhE,5610 +pyarrow/include/arrow/extension/json.h,sha256=gnJSzCVni_oJKxKMoSNBwsuBg1BJzk_goGIE_uTSMJY,2109 +pyarrow/include/arrow/extension/opaque.h,sha256=uMVqSScey_13Ho6V86vfkuoByZni9ufh5BGKgX4bTZk,2920 +pyarrow/include/arrow/extension/uuid.h,sha256=E_Bnp5KNKSxVuvdhQHjYT-0HKa9mzVPbSAQjuZ9N3Pc,2278 +pyarrow/include/arrow/extension_type.h,sha256=5rDE_IuEMAQg05k6wnbo6pu8hOW3-jp9Ab89souwcds,6628 +pyarrow/include/arrow/filesystem/api.h,sha256=Xgy2GOZtBVwDjTaXPDyPPlS9Bwt9gjWXm5I_QbyRbFo,1383 +pyarrow/include/arrow/filesystem/azurefs.h,sha256=urXoeGp29R42-0ILfkKBhzSa3U2DjjVaFmol2kOsb3g,15223 +pyarrow/include/arrow/filesystem/filesystem.h,sha256=H7MEX1259aVrWMsgsWX26tuCEPSJF-iI51J3sKsYec0,29585 +pyarrow/include/arrow/filesystem/filesystem_library.h,sha256=axaof-G9GxBjzXhRIt4azB7HB8VJ49MtGYsL7pSO0A0,1725 +pyarrow/include/arrow/filesystem/gcsfs.h,sha256=wzVfIkqhUp-aw6NFNhMbvl0bczty3HmdiYG36oPCDS8,10533 +pyarrow/include/arrow/filesystem/hdfs.h,sha256=Jn91pjfk6RMx-MuAWsEAKLTyKQ7bDPNA5jMEVzafSgc,4133 +pyarrow/include/arrow/filesystem/localfs.h,sha256=eIhPrpABheQz21WE845ULleTk83e4EtJnES4jALW6mM,4972 +pyarrow/include/arrow/filesystem/mockfs.h,sha256=kohu7s9s9xtd75sGTE2K_rsHW89swDOtSSSFxBixMcc,4768 +pyarrow/include/arrow/filesystem/path_util.h,sha256=hrDVHk4F9M7oGABB4x2wKfQMjSlSAIS0IaLVv2jHrl4,5698 +pyarrow/include/arrow/filesystem/s3_test_util.h,sha256=ffeqZmR8G8YyzbpUWws2oSEchYPBt254jwOHWdkcWQo,2767 +pyarrow/include/arrow/filesystem/s3fs.h,sha256=0C98nH3MLI-lq0FW3mWufnY8z43GWCl4BVOnhgDsFhw,16217 +pyarrow/include/arrow/filesystem/test_util.h,sha256=MFwd6ljnwR8q1smTSpVRLk_15Ch_v1hEQWkRL3lAo-s,11412 +pyarrow/include/arrow/filesystem/type_fwd.h,sha256=zztDER55Wbt4rVnkd-ReeDO-YnrpemftFeFtZ7ZGidY,1462 +pyarrow/include/arrow/flight/api.h,sha256=YotLTQn-KCl6y5BIg8coEFZ9n7PMtJ02ly7Pc5gmX7U,1257 +pyarrow/include/arrow/flight/client.h,sha256=NtFquWOaafBcmdIB4en9ua5xSEJaCBkC1ZHhAU_Gg60,17798 +pyarrow/include/arrow/flight/client_auth.h,sha256=a3Dkm_jPOuqzNsDA4eejuMUwCEBMavM8uS7w81ihbRY,2216 +pyarrow/include/arrow/flight/client_cookie_middleware.h,sha256=5zkCP2SxMFQuTX8N9NHxOve5J_ef2rFO6-xY4Tfnygk,1204 +pyarrow/include/arrow/flight/client_middleware.h,sha256=aAZwCahuiBhP85iMPe7xNWvidBR9KeHGto2YAqJioI4,2948 +pyarrow/include/arrow/flight/client_tracing_middleware.h,sha256=d0sTmUOfq5M9FMliIKK-flJkR6-7r69NjU2TpxhfqWo,1217 +pyarrow/include/arrow/flight/middleware.h,sha256=JPQd8JnIVcwjTH6yOBck4BWR-WV95fpnAdhHyEYvfKE,2254 +pyarrow/include/arrow/flight/otel_logging.h,sha256=riS9sZM2C3mH6VMbESizJ6lGmudqdJhfdCY9_cJJqMA,1139 +pyarrow/include/arrow/flight/pch.h,sha256=Dp2nrZ3t_KPjm0cIMyu913BbCorJG5rmbtpfyDN09bo,1192 +pyarrow/include/arrow/flight/platform.h,sha256=1ZfzVaollAZosGyH_1JvzEA8iNR0hi9cUGz5eyLT1zc,1209 +pyarrow/include/arrow/flight/server.h,sha256=GAcV0-THuBuj-bXfwqYrZ1P2bwZgKQSJLbu8ToltRvU,13185 +pyarrow/include/arrow/flight/server_auth.h,sha256=zKQ8lvkMBuMYiIfT1sU0MPXqVPQikaOS3npBgytcaKk,5429 +pyarrow/include/arrow/flight/server_middleware.h,sha256=ITKjCNTT2qnX7JeqWdaweC_QpCX_ytW9PFucQYmPkFo,4317 +pyarrow/include/arrow/flight/server_tracing_middleware.h,sha256=zR0FFZYGwAAqhzVhPVDjyXfZda9zmLteqauwA5dgR_w,2186 +pyarrow/include/arrow/flight/test_auth_handlers.h,sha256=XkvMWucv9GQjlt2ttvYxshym4kUubUdMh-timlQIt1I,3315 +pyarrow/include/arrow/flight/test_definitions.h,sha256=esAWPIVJxTQqGpPTxa4Dm_HdAnzK-4DoJAb3zFtQBiM,13022 +pyarrow/include/arrow/flight/test_flight_server.h,sha256=SbRhZP0U4ILnbg7lYQvGeXmvPM_B6bai12FTM_HD4RQ,3930 +pyarrow/include/arrow/flight/test_util.h,sha256=E0OlDLwcknevKf4LzzqdU3jfxUMV_mcIJxy4U_up77Q,6860 +pyarrow/include/arrow/flight/transport.h,sha256=ZDXc-f8o00TFWESwsGU1My7rR9OfM3X7OZjDcGXTwIA,12181 +pyarrow/include/arrow/flight/transport_server.h,sha256=iVdXmrb2pemh4o6BxwvB7OZAV4UeoWrbhe4ePZ5Pi4s,5268 +pyarrow/include/arrow/flight/type_fwd.h,sha256=tQFAM3QNKPdzB4VqUGdEUFjNPYXVZLApwGnSus2GQx8,1797 +pyarrow/include/arrow/flight/types.h,sha256=b_HQAdmPTh8sZsk5KI7diTMlfm5TmnPFgc8sHE9KFWs,46638 +pyarrow/include/arrow/flight/types_async.h,sha256=3nIQqwCYO4Ir3Mt2bG7BNntXxuNHYQNNpz-Yl3EaFTQ,2599 +pyarrow/include/arrow/flight/visibility.h,sha256=N1k74cwyRvOaYFa_tCjdgUjiSdPBhmy20UuVGu0wTg0,1596 +pyarrow/include/arrow/io/api.h,sha256=Pn4jZSTsLW8MAlMyXUokmJdupX54u154GYI5AvD5ByA,996 +pyarrow/include/arrow/io/buffered.h,sha256=YFKKAHStUFncnfpwnk0XSZAZLeLX-LAXV1qH9VGaE1k,5845 +pyarrow/include/arrow/io/caching.h,sha256=AAjoyKwQ06m2XiglFS6Ch_cdg2p4-wkA7GakGI_eX1E,6708 +pyarrow/include/arrow/io/compressed.h,sha256=3JxIOo1q8VhjIErfwVM5ZLVkwwQKXd-FT5517j58etA,3774 +pyarrow/include/arrow/io/concurrency.h,sha256=7BSmXQGTJKKMpJVtR4hxpp62KPTIKU1W3DfC17SrlmA,7960 +pyarrow/include/arrow/io/file.h,sha256=-ZEklW1Q0sj3pYCQLQ1ebirKd3s2GI3vUEIszFr8mVU,7625 +pyarrow/include/arrow/io/hdfs.h,sha256=2s3f49ggAYgSCsX5SoqnomwsXd24_IZhW-VSBJclqTg,8559 +pyarrow/include/arrow/io/interfaces.h,sha256=QIBHTJUobEkwcqnKMT_GEKu5ArzpeGmK-8v7z4qGHIQ,13428 +pyarrow/include/arrow/io/memory.h,sha256=htc3MmEbEvwc28bLjCtTtt9QcYp-10WKLmX0V9TnwRM,7048 +pyarrow/include/arrow/io/mman.h,sha256=qoLBAGFcvpYTy96Ga7FNWDJKT3uhxpFAF3hbXIaDSiY,4111 +pyarrow/include/arrow/io/slow.h,sha256=8-ZjQJq49EQJ4esQ6qHHjlKCeZNg4BSND7ire-ZtLYQ,3942 +pyarrow/include/arrow/io/stdio.h,sha256=dqMTHoJbmiXcyNa2fN60tSWQsx0GPphZVCLdGiZNt8I,2095 +pyarrow/include/arrow/io/test_common.h,sha256=Rj8mwgcUkzksrlBALiAldtr_6JGHJFLh2SztGVkRiSA,2112 +pyarrow/include/arrow/io/transform.h,sha256=W9XWonw69VymQAaQptfW7jD-6ry7VCpfPXlkB7aZzOE,1890 +pyarrow/include/arrow/io/type_fwd.h,sha256=Pi7EFpFvBXsFN1xKOyZjTSP95xNDs6W5hxb5GucoVVE,2315 +pyarrow/include/arrow/ipc/api.h,sha256=olkdu82mTS8hmwD53DBJJL6QQ0YBplhs-s-m4uOInSQ,1007 +pyarrow/include/arrow/ipc/dictionary.h,sha256=UTjZPIG8mLZOk9IW2QnR9RZGr1npexZOp103fv-O70E,6104 +pyarrow/include/arrow/ipc/feather.h,sha256=uCnxwO7eUH18kJ-lWz9IWwSj6AjfejqqLdoifJ-UBDo,4918 +pyarrow/include/arrow/ipc/json_simple.h,sha256=IjFjx6Z7h_WLXt1paVIJboUOTR5GFBhWUhCbm_m9lNk,2455 +pyarrow/include/arrow/ipc/message.h,sha256=KtMCbIC2J4-5iyPG5Sijqu_MALxiuKWBYZhGnw0jxOQ,20011 +pyarrow/include/arrow/ipc/options.h,sha256=X2BbCaQ03S1uqedgLRbvLyfb1PHZ7WGRBjDLLCbQMGE,6888 +pyarrow/include/arrow/ipc/reader.h,sha256=NqdrqqAEItO1ecYUINRO7-qhKlYy-CHSJKGI2hdXlRQ,24106 +pyarrow/include/arrow/ipc/test_common.h,sha256=_kWOR_-YKtilcCIWK6I4WYo8fcRt6eBMfxEM4kDtY20,6351 +pyarrow/include/arrow/ipc/type_fwd.h,sha256=Ty8ET7nLI4JJeTqDMyP0pEH9QVj9xs7BpJkZrnrpaPY,1440 +pyarrow/include/arrow/ipc/util.h,sha256=wTkfC9YFKZlAAjyzlmQVZcW90oOj_JatjDN4qz0IxHg,1414 +pyarrow/include/arrow/ipc/writer.h,sha256=hum8E_orkG_X38vgyfyKhGbyvcLJ3AkXEykyBjAXIYg,18870 +pyarrow/include/arrow/json/api.h,sha256=XRW1fP43zVqwy1yabaKctNK9MDZqnxkoHDH1fx5B3Y4,879 +pyarrow/include/arrow/json/chunked_builder.h,sha256=DDuMwrImMECw6Mhfncn2xMOjkFcKUV1O1597_fSFSAs,2365 +pyarrow/include/arrow/json/chunker.h,sha256=dkZOcxsF1Q3ek58P7IoA8f3lQyBQpFvGSFeynNV2Olc,1119 +pyarrow/include/arrow/json/converter.h,sha256=3lXsP3BSdpLPIkFAJnYW9vP8BbX3neVYR_W0zFKClQ0,3134 +pyarrow/include/arrow/json/object_parser.h,sha256=Y_6Oceya06aUyeo-1k047dm2-JUMJa2_w9iyZ-goIRQ,1627 +pyarrow/include/arrow/json/object_writer.h,sha256=UrIrjCkIz7Q5n_FpV5NNPD96gHHdTkvTJaekuGBHwTo,1428 +pyarrow/include/arrow/json/options.h,sha256=EypQgDwLZQbrPnAh45nSPfpGGYrxvLgfp1eAG_l0p3Q,2227 +pyarrow/include/arrow/json/parser.h,sha256=3oIzO5kUs2Takc7t_d5mH7bp1uIcc1M-qbuHmPoSI34,3383 +pyarrow/include/arrow/json/rapidjson_defs.h,sha256=lBJlfuYWIeQQ8awPd3bk4jJc81efr_KzKwG8Klw7t1s,1474 +pyarrow/include/arrow/json/reader.h,sha256=KNO9dCyc2RZs7WxUSEW7bpCYBh_h1C3U52YHYxBnP0M,5212 +pyarrow/include/arrow/json/test_common.h,sha256=YiiY_jswpp7Nu6IW1Y2lBhqWSFRoNaNEy1jHd5qkYHQ,10874 +pyarrow/include/arrow/json/type_fwd.h,sha256=o9aigB5losknJFFei1k25pDVYZgkC2elmRMX1C6aTjo,942 +pyarrow/include/arrow/memory_pool.h,sha256=SjPtWz1tx6Lotr2WeOKCCIw9NQc50Zjez3yzgfr7SDw,11064 +pyarrow/include/arrow/memory_pool_test.h,sha256=qv7csk6hZiO2ELFF-1yukpppjETDDX0nuBFBbPFHtMU,3350 +pyarrow/include/arrow/pch.h,sha256=MaR9bqy2cFZDbjq8Aekq9Gh1vzLTlWZOSHu-GhWP1g8,1286 +pyarrow/include/arrow/pretty_print.h,sha256=ZDlroPRr9_ryCk7h_rjA8pL7BNgaJQ9HnRb2PZU63lg,5529 +pyarrow/include/arrow/python/api.h,sha256=W76VAxYqOxi9BHJddji1B62CmaWDFuBhqI65YOhUnGQ,1222 +pyarrow/include/arrow/python/arrow_to_pandas.h,sha256=jUBEUMKXw70oJdMlgkSf6HitaNweQcc7hxI75_C9WSI,5561 +pyarrow/include/arrow/python/async.h,sha256=C0f8YYmgwBGgDau4xEFsdjukiZB4YvpylETHEZryHOo,2352 +pyarrow/include/arrow/python/benchmark.h,sha256=f-kzyMOlPKDse2bcLWhyMrDEMZrG_JHAPpDJgGW0bXU,1192 +pyarrow/include/arrow/python/common.h,sha256=yjljfJK1f7slZ7DBQ4LTo_pob70zioswJNWazy0p-uM,14412 +pyarrow/include/arrow/python/csv.h,sha256=QxU3B-Hv_RsoEcMGS9-1434ugouL2ygC64Lq6FgviNM,1397 +pyarrow/include/arrow/python/datetime.h,sha256=Bny_THGi2tyUeHxcOuw01O7hNE8B_gave5ABAZQtwTQ,7931 +pyarrow/include/arrow/python/decimal.h,sha256=kDDjLzW07D7d7omWSR4CBF1Ocskp4YSZu4Dtxu-gRUg,4726 +pyarrow/include/arrow/python/deserialize.h,sha256=Q4L1qPCra8-Wzl6oLm44cPOUMVuK1FX01LeGzwNUtK4,4260 +pyarrow/include/arrow/python/extension_type.h,sha256=0gzb42y_mbw4fsYs3u8cwPFLBRlG-kkHQLgbvGtrY0U,3181 +pyarrow/include/arrow/python/filesystem.h,sha256=FG0AcLekqaDf9IQPqKixAfIcY_ZLgIKP5NvvXdtBVUM,5126 +pyarrow/include/arrow/python/flight.h,sha256=u5UnulNJqMuXQLlODUWuoyxq-GtL1HuHmVGNzobUVGc,14311 +pyarrow/include/arrow/python/gdb.h,sha256=H-qvM-nU8a_3Z5tk8PvppTwQtBMSZhQKQIVgRAsRfFg,972 +pyarrow/include/arrow/python/helpers.h,sha256=jVNFEbvJXmCceJti3J3-MnZkNlJoynQNq334tt29bbs,5489 +pyarrow/include/arrow/python/inference.h,sha256=FUFvB4Zy7V-tueXdmbDcqTeLK4xj5GZEeRW5yhiJlsU,2038 +pyarrow/include/arrow/python/io.h,sha256=4jGnodpSUlnVqAVh9fWId7H4WldlLPkXyroABpdaW6w,3858 +pyarrow/include/arrow/python/ipc.h,sha256=SZbw6jCCqLiLNCY3k632GmwHeD_r_xrDS0dhqV49VhY,2259 +pyarrow/include/arrow/python/iterators.h,sha256=Ugfm3JvetAH0l-oAjjpZfhrUBqRimVMaw4-xusvqLSg,7327 +pyarrow/include/arrow/python/lib.h,sha256=UNSuhntc2NTo9y8txHS8MqB10IQN41UuXjb5dGtstfw,4631 +pyarrow/include/arrow/python/lib_api.h,sha256=SCXALS0e94-_uXt9ZlqlUlvU-cclpx7xT8LpxAU1nbM,19487 +pyarrow/include/arrow/python/numpy_convert.h,sha256=y13eHwfe1lJKzadoTr2-GyX6xPsE6Z7FN31s7PN-2Rk,4870 +pyarrow/include/arrow/python/numpy_init.h,sha256=FniVHP7W2YBlenoMYhQrODvoqqvDMSls2JANGtNPQts,999 +pyarrow/include/arrow/python/numpy_interop.h,sha256=rI6ek8JTOYtjo7gEADSDBS6QuAOHa2A0YQPZ2GeypFw,3418 +pyarrow/include/arrow/python/numpy_to_arrow.h,sha256=z9KapsuoOSpWILPt9bea7GR4BL6AQ28T6DUO0mSkh3k,2760 +pyarrow/include/arrow/python/parquet_encryption.h,sha256=Mc8tZ8gIfkH0AckNiIOt6hesP_MVKeKhcytT24ZOLdQ,4861 +pyarrow/include/arrow/python/pch.h,sha256=vkbgStQjq820YeHlXBPdzQ-W9LyzJrTGfMBpnMMqahk,1129 +pyarrow/include/arrow/python/platform.h,sha256=XYS5IqiMUejxN2COzu60Zs8b_wAaGTBw4M-zKVqqs5U,1422 +pyarrow/include/arrow/python/pyarrow.h,sha256=TK3BtD9n3QKOQ9dX3LXbQc0hu9alWcufV0O93iQW7B0,2761 +pyarrow/include/arrow/python/pyarrow_api.h,sha256=7l0G4-_m9yALYoifsY8Z6qh3HHD0PgkpVSgCn_JaGU4,867 +pyarrow/include/arrow/python/pyarrow_lib.h,sha256=-70_Ckj3_0ImlzaXSJOE_d3w9pGM66lXiGPyln9c96Y,863 +pyarrow/include/arrow/python/python_test.h,sha256=ea32mM20uHySlygi9MtVxr26O-ydTZHCUQIlxaIMjT4,1195 +pyarrow/include/arrow/python/python_to_arrow.h,sha256=BoVytf6P7PBYXyznchElKZSFvEsFyimB-tLFdw0AUNo,2521 +pyarrow/include/arrow/python/serialize.h,sha256=HVBhIKgc7A4YOmwYfjE2Hqj1Yxl9suCJb940KxrVcrs,4630 +pyarrow/include/arrow/python/type_traits.h,sha256=B_NsRT_hZG8D91sTcihJyKF5SrslPcFmj12QfbpHuLI,10093 +pyarrow/include/arrow/python/udf.h,sha256=de3R8PhNJO5lT9oCqRxe8e2_SE3jBpHOkwbNqCrlgjQ,3104 +pyarrow/include/arrow/python/vendored/pythoncapi_compat.h,sha256=bzMnlHTCfjk5DQRIxwytunYh5aQxU3iSElaaDyNnAY8,40900 +pyarrow/include/arrow/python/visibility.h,sha256=hwJw5sGrWJckQkNaAuLe4Tf-VDjQbXknyzNOVgZI3FI,1381 +pyarrow/include/arrow/record_batch.h,sha256=qk-6MakursNrRIec5MZeCfjUSYyXPQsyYbB1FJcYb7g,17835 +pyarrow/include/arrow/result.h,sha256=1NmZkkVhjVe1CAI7dFXRFdNQefEtk1lxMCF92o41ROE,17739 +pyarrow/include/arrow/scalar.h,sha256=syIPKehmg60wmde_ySRUZqMTxJ1rEBrIQ9erRTSZbzg,36595 +pyarrow/include/arrow/sparse_tensor.h,sha256=dd6eQmCjfCmmI76hgsC37R-qPJ11IMhafVaxSo2XJFs,25205 +pyarrow/include/arrow/status.h,sha256=2D-uFQpe83Yja8Qygm1cXvWAybuiibyxlavOxFuPEjs,16417 +pyarrow/include/arrow/stl.h,sha256=yGoKi-YUq6DgxkIW27S5B0_rXd2YiUrdzA1YdvHNCHQ,18164 +pyarrow/include/arrow/stl_allocator.h,sha256=TBbvjbuQIH9y88FI2SaqAL7pOIt3wZ1xMKwXqeKNiJE,4956 +pyarrow/include/arrow/stl_iterator.h,sha256=RelNQrADHupKWTuFBCCkqVlyuGHXU3yB6gcsDpQpra8,9953 +pyarrow/include/arrow/table.h,sha256=UoixXGk5S1ckV35utXjbA-KUBQrSeqvfrhSmk22k760,14647 +pyarrow/include/arrow/table_builder.h,sha256=LRcLCL2iUrj6vF4f9AjPswVjqtqlMw7z_8VBAfUJeCo,3763 +pyarrow/include/arrow/tensor.h,sha256=mgPkJ5f5ngl0qDkeYf-uk-BtX7Gyr-0DUuX1qB6YadE,9093 +pyarrow/include/arrow/tensor/converter.h,sha256=RZq0Try_kiZ085_d_CvhewMsd57InGb2TCeiveaf-Oo,2891 +pyarrow/include/arrow/testing/async_test_util.h,sha256=IrHWfPeIyhrgeTGHUPLt92LdsofmFX6khjngWsZv3dY,2262 +pyarrow/include/arrow/testing/builder.h,sha256=4x0bWOedaVomWU0m7dF99irOv3flR-_p-IMofTDZtwo,8556 +pyarrow/include/arrow/testing/executor_util.h,sha256=38_rF-V_9zF1ttJMspkPiI-34VU1RDjg1ADBS8lUFHk,1885 +pyarrow/include/arrow/testing/extension_type.h,sha256=5l_28-SdoO0r6r-nVqkXsfSRFWTLTPgOFEpXzZiqh6U,7430 +pyarrow/include/arrow/testing/fixed_width_test_util.h,sha256=g6yB7RkziU7HEhNJnxOhkn2nE5HeXaFX3tbBX3q9_sE,3091 +pyarrow/include/arrow/testing/future_util.h,sha256=qIhi417OGMWSMUSDHjkGTYd-ihZbqw8ZSIRwJ01vbKg,6246 +pyarrow/include/arrow/testing/generator.h,sha256=h9Kw9GfDnCHDLl7IsEgaLCi8UDu7R6MHL7Au2TWfMVc,12024 +pyarrow/include/arrow/testing/gtest_compat.h,sha256=0NqH39my7m1FMpsrQYnxQx4bdEE10SCXZaysN6yjQFA,1311 +pyarrow/include/arrow/testing/gtest_util.h,sha256=jnVGbM53nnXO433aUNmZHlMyiQ1ftENITLbtqRF6R08,24496 +pyarrow/include/arrow/testing/matchers.h,sha256=3ys7UI6YpFeMvFCgjmF_VWn1w7Hzhqbr2c-_EuJBpnU,16852 +pyarrow/include/arrow/testing/pch.h,sha256=wKPN4rZnVcQbmpn02Sx5tSa7-MEhpUR1w-YJ6drtyRM,1164 +pyarrow/include/arrow/testing/process.h,sha256=AzPW3Lh2R4sTm-RUUi4Od3aSba9zoLcS_zHBxztv4zI,1372 +pyarrow/include/arrow/testing/random.h,sha256=UMxioQORvoZOsodZM6T-ujza5WuYKwAndbvnOImDsqQ,37046 +pyarrow/include/arrow/testing/uniform_real.h,sha256=-G_2J9cvevoCtB55vsCsWtJkMUHLIMyOwdT6G8ZW45Y,2970 +pyarrow/include/arrow/testing/util.h,sha256=Vr_F5jZQo6kd2-PBq5M0IjODeuaY7cNU7dDovpnPtLQ,5391 +pyarrow/include/arrow/testing/visibility.h,sha256=-wjc00QIhygXJa7tknbIL685AQ1wnyCPr-EtVzkzmq0,1606 +pyarrow/include/arrow/type.h,sha256=SJVslP638byBgmRg3xk3wptgYrQ_Gvj-_s78Yx2G8bY,96785 +pyarrow/include/arrow/type_fwd.h,sha256=2stweTjQZvCwuWYBFI_QJu2369tT6Y1Az4AIien0NVU,23442 +pyarrow/include/arrow/type_traits.h,sha256=5XS-cpIzY1DQmNIwzhL7zd4ItxPfOgCwEqWfVG-zU80,54725 +pyarrow/include/arrow/util/algorithm.h,sha256=045EVzsC9rThlRVFaCoBmmtWZmFy5y28PR9yapn9sXY,1229 +pyarrow/include/arrow/util/align_util.h,sha256=DG2L24KReTiU8nFpXLigbflkKouKWTPUf6osQs6mxiY,10669 +pyarrow/include/arrow/util/aligned_storage.h,sha256=ZsAqIA3DV3jIhCnC8mmA4J7FCnnQ-CV-gJj_T_pTmsI,4987 +pyarrow/include/arrow/util/async_generator.h,sha256=dMfy3t58k9zQ82LeD002LZT0uEce_QWoDRfwjIapwKk,77704 +pyarrow/include/arrow/util/async_generator_fwd.h,sha256=Y7EZ4VXdvqp7DnzG5I6rTt123_8kQhAgYIOhNcLvBdA,1737 +pyarrow/include/arrow/util/async_util.h,sha256=1nnAJZ22iK7wSzmvZDo3PMhuWqJIt2qKdlXzTyhoCK4,19759 +pyarrow/include/arrow/util/base64.h,sha256=qzcBE98cg8Tx5iPJAvQ4Pdf2yc6R2r-4yGJS1_DEIeY,1095 +pyarrow/include/arrow/util/basic_decimal.h,sha256=Y6l2AliCqGzeavJq7pD55WS9wVbznkxbjJzMBLXoll4,33136 +pyarrow/include/arrow/util/benchmark_util.h,sha256=SG3gfwE-wGNZAwpL3TvffnSiZGM2cztV5xRBnbqy2Mw,7641 +pyarrow/include/arrow/util/binary_view_util.h,sha256=-sFAQX9cnfWmmZJo8stFX5vkJki7T2UloAvDzYO0MN8,4625 +pyarrow/include/arrow/util/bit_block_counter.h,sha256=iSIemzizxVokwC0Ze6SjSi-al_nrP2ViXF6JPoIVUWc,20162 +pyarrow/include/arrow/util/bit_run_reader.h,sha256=IWDww6Dm8OFsCRlJ0hEpJKiHMK3nUM3pqbd09mZhcIQ,16616 +pyarrow/include/arrow/util/bit_util.h,sha256=S0TbReZet8MpPFZk9wjfYzfKpkBquthkkFk2QtxzB7U,12108 +pyarrow/include/arrow/util/bitmap.h,sha256=qDoNl-S8QFoZ220HsAtAN-s-Xm5JcnjOXNOGdaIssL0,17462 +pyarrow/include/arrow/util/bitmap_builders.h,sha256=zOb7Q-eX9vm9rkgu0Z3ftUDsI1xPthxJ_iC4qDYR1is,1563 +pyarrow/include/arrow/util/bitmap_generate.h,sha256=m6ZsNwx1GhsEktQr63NxXHQkX2B7Nti011XYsPg2xfo,3661 +pyarrow/include/arrow/util/bitmap_ops.h,sha256=87_SXoqmVPRC6umXFitektDCIeI8yOalYWUonzdWjt8,10750 +pyarrow/include/arrow/util/bitmap_reader.h,sha256=pLrMDWhVo-Qb3V1mLASAz_aI6QZxDHRr37EtqxqGd9E,8353 +pyarrow/include/arrow/util/bitmap_visit.h,sha256=myn8k66VrvZnL6R6VW6IDPTfO68VxjbJ8Up5IuSjFL4,3470 +pyarrow/include/arrow/util/bitmap_writer.h,sha256=a4goXhLlY0qcfvYxbfbGD_HZ8Au1wFcbV1tVF3BPaXs,9383 +pyarrow/include/arrow/util/bitset_stack.h,sha256=D49IZZSzZOM2hqh6b-fT0vgRISf1mQnl4oG5nnLBZ4A,2776 +pyarrow/include/arrow/util/bpacking.h,sha256=qiiYXgZLWZcYX6sm75_vBQ6qpHtS1AwasL59YQL2Ptk,1175 +pyarrow/include/arrow/util/bpacking64_default.h,sha256=q7kf_BW62k45v1qMtnJtLIPk8VtJIALc5nXkYmISy3w,196990 +pyarrow/include/arrow/util/bpacking_avx2.h,sha256=ymQJGQc54W3zbrSoktjbAcBnWwbq_SphiXLLI-G6fHg,1009 +pyarrow/include/arrow/util/bpacking_avx512.h,sha256=Z_rAQpiKJEH-9QSHUXpbDmZiAgIm7CPCHfPnwlIZDAE,1011 +pyarrow/include/arrow/util/bpacking_default.h,sha256=nDi4g5JdyWwXa_J3EqE22bG9R4G7Czd6W75F9spRU5U,103760 +pyarrow/include/arrow/util/bpacking_neon.h,sha256=vE-V4E8dpqSjk7dq8kagD07-nhRQKGvcYMhc_dE4nqg,1009 +pyarrow/include/arrow/util/byte_size.h,sha256=Pd2c_3a0IeSOUevhPIlXNkDmgoB06g4c9YCsuRwwSKM,3997 +pyarrow/include/arrow/util/cancel.h,sha256=oW33c4AXSKLHUc5R_1mZ4ssjmLXU_P0Jk6GDO3IwZUo,3651 +pyarrow/include/arrow/util/checked_cast.h,sha256=SR9Qg8NuLSBJw2w1UfgeGvCfT8k7wrbN7BzADQOZfAU,2076 +pyarrow/include/arrow/util/compare.h,sha256=OLrSSyllkY4Sv00IK-37A2d68gr4OwnWJsxn1aF9xTU,1982 +pyarrow/include/arrow/util/compression.h,sha256=fvlURoWJsgO8Hr6Xs_VNaqiOatmIGn9ktVUkYv7pIu4,8427 +pyarrow/include/arrow/util/concurrent_map.h,sha256=wMi9WDHfRuJ_aSFgcJPpsVwGJ9vIJ5agaZ3rVUlwGe4,1775 +pyarrow/include/arrow/util/config.h,sha256=sPqy_ZPB3evV_btgboJMWhuLM5KvS7MElff-VL4u5X8,2269 +pyarrow/include/arrow/util/converter.h,sha256=PILfos6VlnLK6fOFMfLIUhiKl3o1dJo9T4HJXeR7V5E,14637 +pyarrow/include/arrow/util/counting_semaphore.h,sha256=iXHYagqi_-ay73T1uPmv7pG334SY34DUQLSdtD_4_tA,2251 +pyarrow/include/arrow/util/cpu_info.h,sha256=MqLdJabBZkzDjiScaQ7if9dmoAGvXT2QavGoGkho3lU,3964 +pyarrow/include/arrow/util/crc32.h,sha256=4gN0M-SRnxaGKci2ATPbMWZG2TG3YULXjaTpadV0Udk,1337 +pyarrow/include/arrow/util/debug.h,sha256=CPB_oDOuZ_u89e9wM8bGn88mGvClgfa7UDxDph6v9sY,971 +pyarrow/include/arrow/util/decimal.h,sha256=ozY_pRsBgftG73qz0KKEPchFQ5HRTb5oxCcTIdWEL7g,20831 +pyarrow/include/arrow/util/delimiting.h,sha256=JYe9YcWMeFT_ISuojx_VgVqOYLvZ2TiiR2sNn-WdeBQ,7317 +pyarrow/include/arrow/util/dict_util.h,sha256=HipvAVlQ1Q6zNneu9tYOwVUv6NLklBu2IfZ1eoeSpVg,986 +pyarrow/include/arrow/util/dispatch.h,sha256=g6R9w8asCTRyDTFoxUipvdOeh6Ye_FvZBGP6Zwg2t3M,3235 +pyarrow/include/arrow/util/double_conversion.h,sha256=23QU2TFX4hpBZnoqMDyTKxZoH7mU9qkY2vkF1KL8bW4,1243 +pyarrow/include/arrow/util/endian.h,sha256=jp4QoQ9r2vb-oigrlb9AhQW7Lxgxjj7desQjzkEre7g,8176 +pyarrow/include/arrow/util/float16.h,sha256=RaJBIWnDdqj7uw2YskxBM0Wlpnrq7QRbMCiTZLr7gJY,7418 +pyarrow/include/arrow/util/formatting.h,sha256=782wKN6ZKlHO7cQLC8CKCF9STixvLGjXrp_CwRqXyVs,22554 +pyarrow/include/arrow/util/functional.h,sha256=4ljKXSWX3G_lBT2BfLXuG44pzZwVKeaojpLWCniqKyc,5612 +pyarrow/include/arrow/util/future.h,sha256=tsSVDEH2dhXKyvIKl6R9BVBolpPdZXoRRf2-YRbtdxg,32296 +pyarrow/include/arrow/util/hash_util.h,sha256=CjiNVPUJPxXvVJy7ys79aIb7YB6Bm-5nTJAR4DHsxcs,1918 +pyarrow/include/arrow/util/hashing.h,sha256=baLrNZVhO0choWat_Bie2OV821WSTiutqIVfDMjYO6o,32892 +pyarrow/include/arrow/util/int_util.h,sha256=zTOAq57M4pUe469WpnW6I5hNtxe3vGRHlZWhngA1DzM,4859 +pyarrow/include/arrow/util/int_util_overflow.h,sha256=AtvkG7v3-1gVzW5SrFrdVkYuXFtT76_nxrKtzIbz_9U,4895 +pyarrow/include/arrow/util/io_util.h,sha256=U6VTCh0yKUmYPaw2oG-CllJd4J02Gce6b0qTfqFi9E4,13709 +pyarrow/include/arrow/util/iterator.h,sha256=nprqdPs6wrrgi6RHIJ2VMQI1YFya-57wBQfOEmHoKUc,18087 +pyarrow/include/arrow/util/key_value_metadata.h,sha256=wjU6uQGcSmy-YFqMs6rwLP7E4X-0IFBjPrWZstistzQ,3590 +pyarrow/include/arrow/util/launder.h,sha256=C3rNBRh4reuUp8YuRdGQU95WPc8vl4bAY-z5LXgDiuA,1046 +pyarrow/include/arrow/util/list_util.h,sha256=_OmtsDqe-mnZ_7tVWxB2yHdgCJhpiME_RP3nXHzKbdI,2028 +pyarrow/include/arrow/util/logger.h,sha256=p9i4dNgne36LWpFmNSYBYgTQ4kFSao20dJ40LgRRZKQ,6693 +pyarrow/include/arrow/util/logging.h,sha256=eY1sZ1QCcvy5lpJwfOCL2rtRgLjc8V8yDf9usSa9-d4,9694 +pyarrow/include/arrow/util/macros.h,sha256=dqnFiDUrFUyqHyNP4xEr54WgaAEXX8gE4ZG7-i3nfZQ,9336 +pyarrow/include/arrow/util/map.h,sha256=KbKB3QNc3aWR_0YU1S7aF9fdI0VCABGxEF1VES2oOqU,2476 +pyarrow/include/arrow/util/math_constants.h,sha256=2sfWoVc8syHz8X26XgBmejzXStl7hmvKiOh9622oUZA,1112 +pyarrow/include/arrow/util/memory.h,sha256=qsxFgvj_wozO5OxIs6fHdcam7aifpozqc1aE81P91Yo,1566 +pyarrow/include/arrow/util/mutex.h,sha256=n4bsrHK2Q8zbYsQEyNaFqNu__vvqgwo1AfrLLCxfkpU,2554 +pyarrow/include/arrow/util/parallel.h,sha256=iZBn0C7HkQhGNKET5WTXCJ2FftcryCZAyBGwcg7qRvo,3616 +pyarrow/include/arrow/util/pcg_random.h,sha256=nbXowfCJFiy4GjVfF9I8VvB6fxkyR5zNB1FKdnFsYTQ,1252 +pyarrow/include/arrow/util/prefetch.h,sha256=vaE4FPdscbtO0cPbzl8F1PzB1NDO18ytYlEmZCHDjHs,1251 +pyarrow/include/arrow/util/print.h,sha256=X0CfuWzDkq8CNHaEUH3I27Yi4v_zdoOo7sdrTad8Wr0,2444 +pyarrow/include/arrow/util/queue.h,sha256=X9vRZQX3YL_a2Lzwe-zcNNHguR7FoGYmD-Q0THqsCBM,1017 +pyarrow/include/arrow/util/range.h,sha256=yhe5pJiZIiLUO8tYr408Y9yEsFrFd7FrBMeTL2hAOKY,8526 +pyarrow/include/arrow/util/ree_util.h,sha256=waTBOQfwWGHhoAYHTyyhUnM2BSwOqsof_H_akHvUgno,22395 +pyarrow/include/arrow/util/regex.h,sha256=Tj92CttOh2HxS0EKQ_9-sxMBAsQrDOUKNP0ngIJFdP8,1742 +pyarrow/include/arrow/util/rows_to_batches.h,sha256=PZNoLeMCfJJdeHVvUny0UHc5AtS0hctUCi7zUztJpeE,7120 +pyarrow/include/arrow/util/simd.h,sha256=PpKm-aWpZYIYP0NnyGrQceOO9m3_7JbN4uro0IhIT9w,1679 +pyarrow/include/arrow/util/small_vector.h,sha256=dDNNMFpNdtIbxLP3L-h_bv3A8raYv4IVuyLEzUVMgck,14421 +pyarrow/include/arrow/util/sort.h,sha256=cXZvBN_EcXkN5j0xhX2oNisbChT2QKXP9KzDgjXW2_M,2466 +pyarrow/include/arrow/util/spaced.h,sha256=790FFCTdZA-z6qKuEJM5_wG24SqTTVtyj7PKnLBe7_Q,3567 +pyarrow/include/arrow/util/span.h,sha256=2zDPUc5ciTQovM-T32EZt4iMpqcsoL7Y46ovKjo-7ro,5551 +pyarrow/include/arrow/util/stopwatch.h,sha256=ADGbEEU1x-fvp_NsIdTHH5BW0b9jDB8rTAj1WOgkClc,1401 +pyarrow/include/arrow/util/string.h,sha256=hYtg4d3kGQBHdd0vGuKJTlVeueCCgfyD3iq-feMA3p8,5756 +pyarrow/include/arrow/util/string_builder.h,sha256=UwOKPz8BQjtl9ecBZ0INoYWMWUkAVQOd_aC8xZZMCgo,2446 +pyarrow/include/arrow/util/task_group.h,sha256=fI330NoJT8u84AEUA6pSxWrE7UBKn2LaM4DfPFoalqA,4362 +pyarrow/include/arrow/util/tdigest.h,sha256=L6nSj-FVlYLtwKJ94WX9qps9YU6Yg-e3xwP6C0qE7pw,3058 +pyarrow/include/arrow/util/test_common.h,sha256=ZniLT8TvAUdCE2T2YrtlDKdwDNPBpT5e9V1EiPHH9LU,2837 +pyarrow/include/arrow/util/thread_pool.h,sha256=4ztLwkJHQJQmTmqwy8IGDmAo8X4N-o3qi6f91agzkkQ,24426 +pyarrow/include/arrow/util/time.h,sha256=4Xi8JzaYlWFxVaenmCJ7orMgu4cuKELvbtMiszuJHUA,2988 +pyarrow/include/arrow/util/tracing.h,sha256=sVfC_Rj2gwkWKVSKT0l0FOO5c2EGsfYwlkZX4d9ncxA,1286 +pyarrow/include/arrow/util/trie.h,sha256=WBvryYO2sNdoPc-UB-XmQ3WzSed79qIsSg7YWCrvwNY,7121 +pyarrow/include/arrow/util/type_fwd.h,sha256=aC3ZZR2FniFUR3InlZDXH8dknZKvmM0RBocHwFKU_Us,1521 +pyarrow/include/arrow/util/type_traits.h,sha256=F0Gdg_3faM0MmZBOXOspRzUwuxnjKbFaVpJiTEaOXGU,1731 +pyarrow/include/arrow/util/ubsan.h,sha256=dJNGOe0smDe1akrYLdYcIbAWDJNS6Z7NRgqgDnr2emc,2765 +pyarrow/include/arrow/util/union_util.h,sha256=PSssBiw-v-PDen_q75c6OkNO5PwyIPhGbf9PMJj7P2M,1211 +pyarrow/include/arrow/util/unreachable.h,sha256=O1TG4ozCYT3_xvDpJouKWrlFADIEpIemQ28y4DqIwu4,1070 +pyarrow/include/arrow/util/uri.h,sha256=D24zebazFcrKGt7iGpkcGQ87DuF-2AbjPKVkDlq9Nuk,3886 +pyarrow/include/arrow/util/utf8.h,sha256=flGZ786kHo33Xg_zw0zVA9GAT8jYdPUHTVhIPHGjOj8,2031 +pyarrow/include/arrow/util/value_parsing.h,sha256=ypbnIIxfFDfDmELinEiS2RYSkeabYDAfuKPW5YsmfRw,29995 +pyarrow/include/arrow/util/vector.h,sha256=w1lxZG3CU0gq2ZrByeU8QX2A0JeTtooGdaZONUsVlfs,5697 +pyarrow/include/arrow/util/visibility.h,sha256=DFEdl8TCr30r3b7vlpgzJIiA5NsK7eW9UmeL47PgcLk,2835 +pyarrow/include/arrow/util/windows_compatibility.h,sha256=Chme9fWRqYRzfIbLw7V_yeiIWd3F4dFeG6ImHHr4Xqw,1255 +pyarrow/include/arrow/util/windows_fixup.h,sha256=hjoh6zvB8u8OVUQqLtdcrmohMzoAoLy6XJFLxcfFhK0,1435 +pyarrow/include/arrow/vendored/ProducerConsumerQueue.h,sha256=Bz1ks3NDgXXLfT8TMUkE38RpMOSwKRRtwU1e37Y1CUw,6101 +pyarrow/include/arrow/vendored/datetime.h,sha256=tsFbz8LKBFzRzTEOAKZyWRbdFLfnCnZRCK9Tyi1PANs,1103 +pyarrow/include/arrow/vendored/datetime/date.h,sha256=WNhAT0LIHIl-5t27CT4NjHZxQFl9TANLlGTjlUfHPaE,237812 +pyarrow/include/arrow/vendored/datetime/ios.h,sha256=Qnu0iuy2-ein9KkVoSL1t71_W_VFZkdjDVsOnYTnP38,1641 +pyarrow/include/arrow/vendored/datetime/tz.h,sha256=m5JJv7LE7Vukp8h50r90sCfbOSAD2bMVIVQUUxNZeDQ,85347 +pyarrow/include/arrow/vendored/datetime/tz_private.h,sha256=pDkKXYdzfzQ5uh-jcUhURBLqHo00t0UnlimUdiM53Cs,10706 +pyarrow/include/arrow/vendored/datetime/visibility.h,sha256=VCGKzhQOgL1zwGXKl_7lLULfSy0OsPt8FLWHwA4sOtU,1002 +pyarrow/include/arrow/vendored/double-conversion/bignum-dtoa.h,sha256=imGhcg0RywMsFNMYTqp6rlXw2HZCIAla8SC_n92gCqE,4358 +pyarrow/include/arrow/vendored/double-conversion/bignum.h,sha256=RnQ2CPL8Pt6fVCGh_8VDF11e_GyrrwO0IH0uMnTcsEs,5949 +pyarrow/include/arrow/vendored/double-conversion/cached-powers.h,sha256=jjwfR3bue7mNlE5lbTrFR2KlgjRew2OkmjBa7oQO0Qg,3079 +pyarrow/include/arrow/vendored/double-conversion/diy-fp.h,sha256=J-RgqH27jspT5Ubth9pTA9NAZH6e7n1OVhxModgi8Sc,5088 +pyarrow/include/arrow/vendored/double-conversion/double-conversion.h,sha256=J1Tl5-8aFY0A9SnaA9z5Q90jnMxw55illPIuE-jdD5Q,1804 +pyarrow/include/arrow/vendored/double-conversion/double-to-string.h,sha256=C-tKRi0IuLycXgS6CC1oiFkCroOo_-AO0VOjmfe0tlE,23925 +pyarrow/include/arrow/vendored/double-conversion/fast-dtoa.h,sha256=ZAho25fqeP3t2RM0XgqfhTBXQIIicACLpdyHHMRX3JU,4122 +pyarrow/include/arrow/vendored/double-conversion/fixed-dtoa.h,sha256=HLnpxkHjKldm-FBiDRbADYljJBSYbQGP4Gz-sVbiSJU,2828 +pyarrow/include/arrow/vendored/double-conversion/ieee.h,sha256=CVKA9RXSjv4ZygqDHMiF-H2hUh3QHQvp1GZYC3MAhkE,15281 +pyarrow/include/arrow/vendored/double-conversion/string-to-double.h,sha256=Ul6b-2R0pjUaAWNM3Ki4kH933LqrW6_XfPz4BSiE2v8,10906 +pyarrow/include/arrow/vendored/double-conversion/strtod.h,sha256=6xCRm47vmcghYJug5mhhTVbsZ3m3Y6tQfMehEyVZNx0,3096 +pyarrow/include/arrow/vendored/double-conversion/utils.h,sha256=wFRb5cGABiNoUSCnvKmdv_KIMcBtX1PX89tPFfvgbQI,15614 +pyarrow/include/arrow/vendored/pcg/pcg_extras.hpp,sha256=FEYzq8NFxPfdJyLs4kVtTBLkaD6iO71INz9EJnaxTdc,19784 +pyarrow/include/arrow/vendored/pcg/pcg_random.hpp,sha256=7TaV3nZhcwpf6XxlZ6cod1GaW5gm-iUn67t2fiMPNbA,73501 +pyarrow/include/arrow/vendored/pcg/pcg_uint128.hpp,sha256=r8exMtH21S8pjizyZZvP8Q8lAdxkKF22ZEiurSTFtzM,28411 +pyarrow/include/arrow/vendored/portable-snippets/debug-trap.h,sha256=9KphJ9gRtDT9DXR9iZ7aS23xa2T8tLmLsFEJMg0pLDQ,3081 +pyarrow/include/arrow/vendored/portable-snippets/safe-math.h,sha256=q9yWh34bsFu1vSqLTuI3n_cIU4TlY98Lk1elxKHvZP0,48167 +pyarrow/include/arrow/vendored/strptime.h,sha256=q1IZi5CvyUp_PNzbQ4_XLroAV24VEovBEz2TkpwUJ9c,1212 +pyarrow/include/arrow/vendored/xxhash.h,sha256=MUwtyzu7xjkx9mBcS65SaDcCK7tgeqQgj-KYEMxcHWc,844 +pyarrow/include/arrow/vendored/xxhash/xxhash.h,sha256=videnbIaUDw38kaDzbSQjyNwo-NauW4CxOpz3I45nEM,253096 +pyarrow/include/arrow/visit_array_inline.h,sha256=XuQjuME8XZeJp7W86YuCsuoVVgmG1NulXAA0KJkmmB0,2446 +pyarrow/include/arrow/visit_data_inline.h,sha256=4MkdFVsrjhMyTDNrScQtOYV_nwzqR2ddSS2yYnbyLt0,12460 +pyarrow/include/arrow/visit_scalar_inline.h,sha256=KvNY0j8nE9gs_805LXMV3ATgvxvUqW4UeKpXUxR3rMA,2419 +pyarrow/include/arrow/visit_type_inline.h,sha256=45aoF8APn8hm909nLBngls669o2yKCn24WlL5XdDpa4,4397 +pyarrow/include/arrow/visitor.h,sha256=NKos98j54uY9tdXzctI_n_nwFRrXNOwanxLDqDZONw4,8690 +pyarrow/include/arrow/visitor_generate.h,sha256=n2YKZW-5hY7ICQSwEUBZIYh2eg9ZoTfD54XRd9OlNDo,3324 +pyarrow/include/parquet/api/io.h,sha256=Ricq0d2R4QXHiGZCbjxZ_0F_QmKq0IrfTidNu5NoXPI,847 +pyarrow/include/parquet/api/reader.h,sha256=vnM5XDPn1TVsDJk4SDgb3ZU2Ta4vdrRzCpDWO90rYHk,1204 +pyarrow/include/parquet/api/schema.h,sha256=KsNJ529pEh7bGUa0rLUCcfanI9rW2uSTirgpvKq0hdc,855 +pyarrow/include/parquet/api/writer.h,sha256=UJZbY8QGVRMtAmozzjoM9TnI4gssqlNFUKCXBw2IfuI,1007 +pyarrow/include/parquet/arrow/reader.h,sha256=l4R351BVOWpYJOv_vyqWmXdJUErm2z_ztvTAv537q0w,15305 +pyarrow/include/parquet/arrow/schema.h,sha256=Mi56ul7itNS6NDbMpKOJCufjHVqaSY5_rbsNRNLE560,6204 +pyarrow/include/parquet/arrow/test_util.h,sha256=Edb5eSSEwkIExpHZ9Q0LJgPzggWNry4WMQ_i4q9z1uo,20540 +pyarrow/include/parquet/arrow/writer.h,sha256=XicHPFeGb92AcsNRDblJ7V4Hmst2qSPGYYT9MTSNNmI,7095 +pyarrow/include/parquet/benchmark_util.h,sha256=RhFvoDBVyfd5Sv0fm9JO4JrXWJRGYYmIIrHXi0cSJP0,1756 +pyarrow/include/parquet/bloom_filter.h,sha256=TC3OxK0J2v6tHxT_Bbw7mlYtM0603KXgBoHRvmzM9aA,14999 +pyarrow/include/parquet/bloom_filter_reader.h,sha256=63kpHYKs5TPrbRamkBLZsDYbD-I9UeVhF-R8d7JHeLg,2892 +pyarrow/include/parquet/column_page.h,sha256=_BbPcMfSa52JmteUMdsc7BW6KWoGXn9aQepDgr0veSE,6526 +pyarrow/include/parquet/column_reader.h,sha256=3QwlHlpiS5e5jtWmI_kRmD4jrrC8ljfpqF0ilf5JgNI,19299 +pyarrow/include/parquet/column_scanner.h,sha256=HecBvh-z0n_1HJsD-GIdcGHQAvDOHKlLzppB9RBsD9s,8863 +pyarrow/include/parquet/column_writer.h,sha256=Y9VN1eJtsYmQVhpL9UPiWGrHbgSDbDds19Z1nv_yfOA,12294 +pyarrow/include/parquet/encoding.h,sha256=jSYqNVLnsKFu95Mb3uhTP06-7La5_6kNJwn00VqSK_Q,16341 +pyarrow/include/parquet/encryption/crypto_factory.h,sha256=RT4iznr6uvSIPbUzh_7s6Cexe8uMbQkzgrjCTGYBC6I,7057 +pyarrow/include/parquet/encryption/encryption.h,sha256=bHJ7USckzezXfydqjJstljcjuR15r8U6zh8z3IoINCo,19842 +pyarrow/include/parquet/encryption/file_key_material_store.h,sha256=YzAVO3M2H5v5Fz2b_WlmB3GE5wVbMEnFTL3S9XPH6k0,2200 +pyarrow/include/parquet/encryption/file_key_unwrapper.h,sha256=pB30St8lGEaEAxNcwnDnlGtATTvc1muMzNOusfgqzT8,4635 +pyarrow/include/parquet/encryption/file_key_wrapper.h,sha256=d2W4xICbSRAy7aPe5RKahhPhiJDfvxHY_v_lifq7wqY,3762 +pyarrow/include/parquet/encryption/file_system_key_material_store.h,sha256=9H1ey0O3LL4dg9VVeFLNxlZ7Vr263JVaZHKVSu4s8MI,3573 +pyarrow/include/parquet/encryption/key_encryption_key.h,sha256=0c3ZrRud2vrCu5z513ocyPYxlsP2kg1fQ8m0Jqr701g,2232 +pyarrow/include/parquet/encryption/key_material.h,sha256=kPTSIuRFYOnH4BCPIB33zG9hp5D2Ba-5kZVlq3rFnRI,6221 +pyarrow/include/parquet/encryption/key_metadata.h,sha256=Pc0nA9LW3Fc9NLMMxz7osbw8si2jSiOVTES-J-9R0y0,4003 +pyarrow/include/parquet/encryption/key_toolkit.h,sha256=HPabI8qFnIMgxZYhHgXCzYV0LU1c5yJ16xjUx21I9b0,4577 +pyarrow/include/parquet/encryption/kms_client.h,sha256=D34pVHzkCbWqKnPIBYfs6cONxmuYzyLSS9-C52ZFhz0,3151 +pyarrow/include/parquet/encryption/kms_client_factory.h,sha256=VZ97CMgDQxx5oZWFGprjXsaM1hZ0wNudPmFU1_lniAc,1293 +pyarrow/include/parquet/encryption/local_wrap_kms_client.h,sha256=XZxkEct0-Tv93VDpda9sDou1kp9qkTKMxr36bpVcI8s,3954 +pyarrow/include/parquet/encryption/test_encryption_util.h,sha256=zIGeULeTOCU1N-XYHdvIppth5wnnTYEwf2h-OuTcQZQ,5209 +pyarrow/include/parquet/encryption/test_in_memory_kms.h,sha256=jYc5WPsrh_wcaaaWcjf23Gbiye3a_bdg2royUfukWEs,3521 +pyarrow/include/parquet/encryption/two_level_cache_with_expiration.h,sha256=cuHbX9gBWWyd0IPXNVjMmHxjPw7omYTns4If4YhBgSM,5075 +pyarrow/include/parquet/encryption/type_fwd.h,sha256=dL8snyUwNjhTQE2FQ2dXAUjTboEXhH2JOehQovHfixc,955 +pyarrow/include/parquet/exception.h,sha256=yc5A3iMqM9P59hnjuY8VXUIoF_JvbZVPHM6_wPtg4cI,5599 +pyarrow/include/parquet/file_reader.h,sha256=OFRKhwAww2N24aZOZcznzral1Or1TGIFGRd1aACARLQ,9664 +pyarrow/include/parquet/file_writer.h,sha256=6fK6Mn-MdiQ-J4oo8BTi_eVVVshlffoQiJzFaLRrqco,9343 +pyarrow/include/parquet/hasher.h,sha256=HSY1EjPD2xx_dB9HtAg-lXL7hB4j9MDE0cAlR7u0NOc,5227 +pyarrow/include/parquet/level_comparison.h,sha256=5z4fUJJPWq9W60l2CsAI7T7E2auGYD7m0fpR5rfLmsw,1306 +pyarrow/include/parquet/level_comparison_inc.h,sha256=r20_6Rv5L7UmFGJ68f-JaZ5hLXb87wvZa80hZNQoF-I,2494 +pyarrow/include/parquet/level_conversion.h,sha256=OsuqK1xiUnEnOLPKwfm9X-pXTaXRMlDIkj3lwGb2ggI,9432 +pyarrow/include/parquet/level_conversion_inc.h,sha256=0r2Gfd_FMidLGFC_a8kgpC9bnUt2-IBbAn9QbQFTrTo,14161 +pyarrow/include/parquet/metadata.h,sha256=ORXKWkfSM-64vTrZ-qrsQ5naKx_pk8XbjJEPwtct7wI,20751 +pyarrow/include/parquet/page_index.h,sha256=qBKqiq131jCUrtFCfwlBkeb8PL96yOPKg7AqkslnM60,16399 +pyarrow/include/parquet/parquet_version.h,sha256=7Xw9wd-fT-B6cgEw2r4N_obNTRsgsqYKZMnK52pe1t4,1164 +pyarrow/include/parquet/pch.h,sha256=zIdkjZS4kuFYra3woGMjmvYXCwB4IaXdpm_nR5Nz8hk,1249 +pyarrow/include/parquet/platform.h,sha256=VS0zEUC4d37LQmlQLQZ5aHNaiwRf8QrxixXdWf73m5Q,3898 +pyarrow/include/parquet/printer.h,sha256=_sJ5IoEj4naSTWxlhbq2Pc6WkNG3wMuxRy8zfKfsAJ8,1540 +pyarrow/include/parquet/properties.h,sha256=X5zn-xdztONv4QfK-gcfdh1CBAuq27cVj9jZQgQNqfA,46415 +pyarrow/include/parquet/schema.h,sha256=CjZh2i9WN5VeoDbLqy7M1AZtopZ43_C9blWG3OT2IfU,18222 +pyarrow/include/parquet/statistics.h,sha256=0sk7koXslu-KuVC6CsTiFVD1Fu_ZWPD_FLhcXALas_g,15176 +pyarrow/include/parquet/stream_reader.h,sha256=1WmN0vYCqTz1Lwb_Di4xPWTE-VbCQQuzZralSpWQm3U,8791 +pyarrow/include/parquet/stream_writer.h,sha256=nw_v3nhrL682ozZ2KZKVkHnOsjwexbmBXTV2CKcq4YQ,7505 +pyarrow/include/parquet/test_util.h,sha256=gkJoOl_N4cG3L56uXVJi1RLiDVBl73yX01Dkx2Plt9g,31180 +pyarrow/include/parquet/type_fwd.h,sha256=qx6Dhg1HO0U99jdiUfu3rC7zhmQ-3i7WXsfEhrza3rE,3046 +pyarrow/include/parquet/types.h,sha256=IFbKlP0aZzW8Cn4U0QCIGboVb8hOnD6UvSGi6EqpvvE,25482 +pyarrow/include/parquet/windows_compatibility.h,sha256=xIEGHW354URgdIP9A4V303TJL8A1IkCEvp08bMKsHTU,897 +pyarrow/include/parquet/windows_fixup.h,sha256=DpyWCywx8YIqouun6BJcgMrHFMTCBgowWdJ1mnJnQ2s,1052 +pyarrow/include/parquet/xxhasher.h,sha256=QAa7ZE7S3UFtU_Voz3oi3YclIYhbhviJkafLOYgiuWg,2074 +pyarrow/includes/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +pyarrow/includes/common.pxd,sha256=tYI1M3gk_d-uzNUpLcIxhNG5W67ycFSVb36Tv7hyN30,5452 +pyarrow/includes/libarrow.pxd,sha256=zOwU6egOTsU45dV0z0sEVLMu6N2iNXXxNB4R3R2QlyA,114590 +pyarrow/includes/libarrow_acero.pxd,sha256=c84RdYfIuFWW_36-1RELJsowfQwXhgUxbdC_xKQyFCI,5298 +pyarrow/includes/libarrow_cuda.pxd,sha256=0fRcHbCZY_gFdwIXIElnpGvTxeA5xVxZH1-vwZh16SM,4942 +pyarrow/includes/libarrow_dataset.pxd,sha256=LVHtNouC3ZWMmyD48JkYGXajf22Wax-FgzAV4URqySs,16993 +pyarrow/includes/libarrow_dataset_parquet.pxd,sha256=4me_u82JiInHNRvoazLXUTOO5sxVnyCk-BdfsYQZyWQ,4536 +pyarrow/includes/libarrow_feather.pxd,sha256=MTJUDQbfKP8Ir700Fobl7xcbjX7WcrsUV4mxFXlfwn0,2140 +pyarrow/includes/libarrow_flight.pxd,sha256=pcVtpB4Rx81RZoG3afIizmyQuTnckrqIPZyjvsIYYKE,24860 +pyarrow/includes/libarrow_fs.pxd,sha256=jG1sBGyTkU3X_XZKBMC-n3YsY8Po_2dIQdXyK9vXtHY,14973 +pyarrow/includes/libarrow_python.pxd,sha256=Fs9hNJZ-_fdVmqkNu3zGRUXy8Azt6_zniX_p1SKqM64,12387 +pyarrow/includes/libarrow_substrait.pxd,sha256=5ZJ0yHhM54I1GfmUaPMy5nRxLFsr-A625qUSmOhnQO8,3196 +pyarrow/includes/libgandiva.pxd,sha256=FLBd99IeU67Db9SnHS7oe6FgBZ1aIHuRc0pOiDv7hQc,11538 +pyarrow/includes/libparquet_encryption.pxd,sha256=fi3QrLpHN1_IaYRXvVMJdIgp7F_6aaLu1owP0I3BD5g,5898 +pyarrow/interchange/__init__.py,sha256=DH0bwbKpdjD1WCW1VinnXEuVLY098uHKkirv7DFc9JM,845 +pyarrow/interchange/__pycache__/__init__.cpython-310.pyc,, +pyarrow/interchange/__pycache__/buffer.cpython-310.pyc,, +pyarrow/interchange/__pycache__/column.cpython-310.pyc,, +pyarrow/interchange/__pycache__/dataframe.cpython-310.pyc,, +pyarrow/interchange/__pycache__/from_dataframe.cpython-310.pyc,, +pyarrow/interchange/buffer.py,sha256=NF_GU1uQ6INqHqCwzY6XQQqRxKDh6znEeDHiRqaEIQ0,3359 +pyarrow/interchange/column.py,sha256=afU794n3H7yf4gDQDuFLbtyDlgVnLk9iZ6sugb0h8_4,19370 +pyarrow/interchange/dataframe.py,sha256=tmSMmBvBAc-ZSUzE8tBNbvQLHuuxLuBkMkK6KYwtS8M,8405 +pyarrow/interchange/from_dataframe.py,sha256=JfkP4wuY_9x76H6RDtmsOzs6B6qe-1WS7zxpKeD481s,19709 +pyarrow/io.pxi,sha256=LcEqNanwQD7dr0XVHu52dnhlUUH25bhjDGGPO6Wet34,86616 +pyarrow/ipc.pxi,sha256=Reakb_rHbBipOr9QPEC0D2jBvQ87ORpVb5kasDdeY_4,41081 +pyarrow/ipc.py,sha256=Hb3qCPKRr_wth5u4WrkZHJyAZmIK5SoVSezfBOI97Ww,10107 +pyarrow/json.py,sha256=N9Y7_3TSrOEDy2OrmgQ8UKqUPMx1Bm9dYgot-brJ8Xw,858 +pyarrow/jvm.py,sha256=tzAsIrMSCIeNAtSC8lZWjQS0rq7kjaQDPlePDmvpqDw,9593 +pyarrow/lib.cpython-310-x86_64-linux-gnu.so,sha256=t4KkYmRDzKJFHNhmWSoCwmpcmdMl2u1TaLsw0yqH5w0,4786616 +pyarrow/lib.h,sha256=UNSuhntc2NTo9y8txHS8MqB10IQN41UuXjb5dGtstfw,4631 +pyarrow/lib.pxd,sha256=repMfzMLwO9NOjVyJbVn5R_vBQJJhD507YcD1wvaB8g,17964 +pyarrow/lib.pyx,sha256=Pe9ERxojd9KzxzqWJ60B8OJHH8Z1fFYg3bUx8ZDFUtk,6016 +pyarrow/lib_api.h,sha256=SCXALS0e94-_uXt9ZlqlUlvU-cclpx7xT8LpxAU1nbM,19487 +pyarrow/libarrow.so.1801,sha256=ZP7oUszK9KE6Ovf1ThZrbCN1aNcjO0-bDbXqXxRatrM,63816496 +pyarrow/libarrow_acero.so.1801,sha256=ucWlroFOdfuifavQ_NAy9mXg3oVbOLlW_eXa0aInnEk,2086504 +pyarrow/libarrow_dataset.so.1801,sha256=ccKk-lUbYp8PDc2sGUVBY_h475Dncc53My5HOlYBhsk,2763968 +pyarrow/libarrow_flight.so.1801,sha256=CCucUQkvGJlxlAxv65vIufIzb34BDLX2R8zq0NUkYyY,20274112 +pyarrow/libarrow_python.so,sha256=Qnq9g5kvGMZk0VHxjJXI6t2lg7WIijO-bN5LaDm1I-E,2878024 +pyarrow/libarrow_python_flight.so,sha256=F3zrYWNSPKQSF6aS-dklxPlnK0yQFQ_L5wMo6re0dIE,117984 +pyarrow/libarrow_python_parquet_encryption.so,sha256=ug1Gwq4da2ONn1EUI3wkrc4cj3LrX1vKCrPpgUPBUKE,37552 +pyarrow/libarrow_substrait.so.1801,sha256=2OsEN65_y962IRTnrsK4NNPZ4A9s10V4U4sWRnnMqjI,5348016 +pyarrow/libparquet.so.1801,sha256=EqZcHoVDUsMU59EOqgLc-tB7ngVShVkH0xBJdRn25YY,11042272 +pyarrow/memory.pxi,sha256=9AVMENxqaV0Ndf9tYSiakunEpMRRCZNT9d-PnrY8r14,8229 +pyarrow/orc.py,sha256=IjjeGAEZl0KhHvwy3YsSGfTWlx7Ilb54P0tFKPvwcfk,12618 +pyarrow/pandas-shim.pxi,sha256=d3Z0mki6n3QUTzCOJoEhvgUBcCIcWPsuBli65ZQ_gBg,8178 +pyarrow/pandas_compat.py,sha256=sMLsO2ufQeRxpZadNHv4AEG2FGP8EstyOglL38sqAeA,42775 +pyarrow/parquet/__init__.py,sha256=4W64CbvwvO60tG58nfNtyCwMVCfuPumtu82p-kiGPaE,822 +pyarrow/parquet/__pycache__/__init__.cpython-310.pyc,, +pyarrow/parquet/__pycache__/core.cpython-310.pyc,, +pyarrow/parquet/__pycache__/encryption.cpython-310.pyc,, +pyarrow/parquet/core.py,sha256=SA1zMIm-0cnTPMCjgWe_Bu6bFbjBbTWBpfYauGcHpW8,90440 +pyarrow/parquet/encryption.py,sha256=-XW7Qcbl-jQhpZsR610uQ8-z9ZVE_NL045Jdnp1TZ9M,1153 +pyarrow/public-api.pxi,sha256=EO0_0FZz0JK9_SfuHBPN0ljwwAU7Gv6jGl1WG_BSGsE,13781 +pyarrow/scalar.pxi,sha256=hRcUS1nHQILBp8eL3vfhRXp4yXrvVRPBBoD8ALVdhZ8,35388 +pyarrow/src/arrow/python/CMakeLists.txt,sha256=D4Ypror_508aAd_juYkrS9Qu2maeirK4QXzwGEZEj0M,855 +pyarrow/src/arrow/python/api.h,sha256=W76VAxYqOxi9BHJddji1B62CmaWDFuBhqI65YOhUnGQ,1222 +pyarrow/src/arrow/python/arrow_to_pandas.cc,sha256=z22z8UmNl69KGbmbZLwgZhApNyD9x7xolCSC_3_g6oE,95737 +pyarrow/src/arrow/python/arrow_to_pandas.h,sha256=jUBEUMKXw70oJdMlgkSf6HitaNweQcc7hxI75_C9WSI,5561 +pyarrow/src/arrow/python/arrow_to_python_internal.h,sha256=nQXPZTL3xa4Sm-a-Gv-8bpFs-qAOZHkqWmA_m-dSLVw,1740 +pyarrow/src/arrow/python/async.h,sha256=C0f8YYmgwBGgDau4xEFsdjukiZB4YvpylETHEZryHOo,2352 +pyarrow/src/arrow/python/benchmark.cc,sha256=z6qYRx4qMuNXPaC8fuPJlQd92aosMN85u1aD50R1-UU,1293 +pyarrow/src/arrow/python/benchmark.h,sha256=f-kzyMOlPKDse2bcLWhyMrDEMZrG_JHAPpDJgGW0bXU,1192 +pyarrow/src/arrow/python/common.cc,sha256=_9ozIRo_WTDWovBKqOVyX28d0IttHvwW9MG-PkTzmKc,7591 +pyarrow/src/arrow/python/common.h,sha256=yjljfJK1f7slZ7DBQ4LTo_pob70zioswJNWazy0p-uM,14412 +pyarrow/src/arrow/python/csv.cc,sha256=ql5AY76AqiFksWsrmzSl551k5s9vS8YcmypM2A9rhw8,1803 +pyarrow/src/arrow/python/csv.h,sha256=QxU3B-Hv_RsoEcMGS9-1434ugouL2ygC64Lq6FgviNM,1397 +pyarrow/src/arrow/python/datetime.cc,sha256=_VKRKeyFqR7Xzay2wazcveb7mgOv8K37ebMomNY__lQ,23001 +pyarrow/src/arrow/python/datetime.h,sha256=Bny_THGi2tyUeHxcOuw01O7hNE8B_gave5ABAZQtwTQ,7931 +pyarrow/src/arrow/python/decimal.cc,sha256=66Hy-u-_fcZtm_0v7npDtPNoiX-mkRJTwCj3FpSyIqc,8848 +pyarrow/src/arrow/python/decimal.h,sha256=kDDjLzW07D7d7omWSR4CBF1Ocskp4YSZu4Dtxu-gRUg,4726 +pyarrow/src/arrow/python/deserialize.cc,sha256=ogtBX7OzGuDvyj_LepFkaG7m53-wenf3duG0WF8Ooa0,19185 +pyarrow/src/arrow/python/deserialize.h,sha256=Q4L1qPCra8-Wzl6oLm44cPOUMVuK1FX01LeGzwNUtK4,4260 +pyarrow/src/arrow/python/extension_type.cc,sha256=eU5P7pufWjcEcmVeOyu1jtEZ08AWd9tkTSMfx8ph0rQ,6860 +pyarrow/src/arrow/python/extension_type.h,sha256=0gzb42y_mbw4fsYs3u8cwPFLBRlG-kkHQLgbvGtrY0U,3181 +pyarrow/src/arrow/python/filesystem.cc,sha256=0twavI91TE20Otq5kkVUwnN5sindU_mBWoVAvz1ZMgI,6152 +pyarrow/src/arrow/python/filesystem.h,sha256=FG0AcLekqaDf9IQPqKixAfIcY_ZLgIKP5NvvXdtBVUM,5126 +pyarrow/src/arrow/python/flight.cc,sha256=Iz4wAyhX7mksabELtRljCOsXRRzuYzu38Rv_yQKJarw,13995 +pyarrow/src/arrow/python/flight.h,sha256=u5UnulNJqMuXQLlODUWuoyxq-GtL1HuHmVGNzobUVGc,14311 +pyarrow/src/arrow/python/gdb.cc,sha256=Z0WLBYHWBzc4uExNG7nWJeRnUBAVSqo_DFpKYry0aAE,22667 +pyarrow/src/arrow/python/gdb.h,sha256=H-qvM-nU8a_3Z5tk8PvppTwQtBMSZhQKQIVgRAsRfFg,972 +pyarrow/src/arrow/python/helpers.cc,sha256=zrrUI56RGrZ8VBzR2dJFJoRq7L6chlX7289HK7tjoOA,16627 +pyarrow/src/arrow/python/helpers.h,sha256=jVNFEbvJXmCceJti3J3-MnZkNlJoynQNq334tt29bbs,5489 +pyarrow/src/arrow/python/inference.cc,sha256=Gm-lOXDzqcbef6gdgCQa5eXPuh8uvYqz9iUjKS2_yO4,24350 +pyarrow/src/arrow/python/inference.h,sha256=FUFvB4Zy7V-tueXdmbDcqTeLK4xj5GZEeRW5yhiJlsU,2038 +pyarrow/src/arrow/python/io.cc,sha256=ZARQCv4WQmHDQrA1dlNZt6mJuPhyK8wNuGm7zoL6V78,11936 +pyarrow/src/arrow/python/io.h,sha256=4jGnodpSUlnVqAVh9fWId7H4WldlLPkXyroABpdaW6w,3858 +pyarrow/src/arrow/python/ipc.cc,sha256=3D9iMbOFHlhNXX4432wsfbfjWvDryZWgdA0Ak19V_8Q,4472 +pyarrow/src/arrow/python/ipc.h,sha256=SZbw6jCCqLiLNCY3k632GmwHeD_r_xrDS0dhqV49VhY,2259 +pyarrow/src/arrow/python/iterators.h,sha256=Ugfm3JvetAH0l-oAjjpZfhrUBqRimVMaw4-xusvqLSg,7327 +pyarrow/src/arrow/python/numpy_convert.cc,sha256=166BIW7zVTRMKogxLUuhV4e5jOevmonvRtXDydNujgc,21194 +pyarrow/src/arrow/python/numpy_convert.h,sha256=y13eHwfe1lJKzadoTr2-GyX6xPsE6Z7FN31s7PN-2Rk,4870 +pyarrow/src/arrow/python/numpy_init.cc,sha256=cJKOH946T7VCcB-gVIoGgfbWTrbj3FPkI4TgnsLTf7s,1178 +pyarrow/src/arrow/python/numpy_init.h,sha256=FniVHP7W2YBlenoMYhQrODvoqqvDMSls2JANGtNPQts,999 +pyarrow/src/arrow/python/numpy_internal.h,sha256=F9p-hzTKCIhRqgtZbsoyPox7RR85YcEw6FYkFF8KqfM,5314 +pyarrow/src/arrow/python/numpy_interop.h,sha256=rI6ek8JTOYtjo7gEADSDBS6QuAOHa2A0YQPZ2GeypFw,3418 +pyarrow/src/arrow/python/numpy_to_arrow.cc,sha256=55-VSQlg10MAZTR0G3I7maErexO8-FDk_27SYdvVlk8,30238 +pyarrow/src/arrow/python/numpy_to_arrow.h,sha256=z9KapsuoOSpWILPt9bea7GR4BL6AQ28T6DUO0mSkh3k,2760 +pyarrow/src/arrow/python/parquet_encryption.cc,sha256=RNupwaySaVHKX_iCYOPK0yJWkTUpqbrpbCW2duWJ3kU,3567 +pyarrow/src/arrow/python/parquet_encryption.h,sha256=Mc8tZ8gIfkH0AckNiIOt6hesP_MVKeKhcytT24ZOLdQ,4861 +pyarrow/src/arrow/python/pch.h,sha256=vkbgStQjq820YeHlXBPdzQ-W9LyzJrTGfMBpnMMqahk,1129 +pyarrow/src/arrow/python/platform.h,sha256=XYS5IqiMUejxN2COzu60Zs8b_wAaGTBw4M-zKVqqs5U,1422 +pyarrow/src/arrow/python/pyarrow.cc,sha256=Pul4lmF7n5Q9cSzgBSvPArWfZY_qDyAq1a_tyMIQGRA,3677 +pyarrow/src/arrow/python/pyarrow.h,sha256=TK3BtD9n3QKOQ9dX3LXbQc0hu9alWcufV0O93iQW7B0,2761 +pyarrow/src/arrow/python/pyarrow_api.h,sha256=7l0G4-_m9yALYoifsY8Z6qh3HHD0PgkpVSgCn_JaGU4,867 +pyarrow/src/arrow/python/pyarrow_lib.h,sha256=-70_Ckj3_0ImlzaXSJOE_d3w9pGM66lXiGPyln9c96Y,863 +pyarrow/src/arrow/python/python_test.cc,sha256=Jg35rRR7BtXOS1012RFOdLViFlVC3zlXV--w8aEzf8I,32397 +pyarrow/src/arrow/python/python_test.h,sha256=ea32mM20uHySlygi9MtVxr26O-ydTZHCUQIlxaIMjT4,1195 +pyarrow/src/arrow/python/python_to_arrow.cc,sha256=K6tVQK1phrrJQzz_TJVmEdfcX-fJfBAkPIeQlypRirY,47145 +pyarrow/src/arrow/python/python_to_arrow.h,sha256=BoVytf6P7PBYXyznchElKZSFvEsFyimB-tLFdw0AUNo,2521 +pyarrow/src/arrow/python/serialize.cc,sha256=FOAsdyfRETe_bCSxC1vc3-oq9Rs9SsU4kDQFTwrdvQM,32667 +pyarrow/src/arrow/python/serialize.h,sha256=HVBhIKgc7A4YOmwYfjE2Hqj1Yxl9suCJb940KxrVcrs,4630 +pyarrow/src/arrow/python/type_traits.h,sha256=B_NsRT_hZG8D91sTcihJyKF5SrslPcFmj12QfbpHuLI,10093 +pyarrow/src/arrow/python/udf.cc,sha256=69DuHRjV6rUAbZqkWEKEUG3ODuHg9ym52lnH7A_lM5Y,29814 +pyarrow/src/arrow/python/udf.h,sha256=de3R8PhNJO5lT9oCqRxe8e2_SE3jBpHOkwbNqCrlgjQ,3104 +pyarrow/src/arrow/python/vendored/CMakeLists.txt,sha256=02XvDJAdKiajCEBOmnMKBpmzbRU7FPkNdlNXtw0-A24,837 +pyarrow/src/arrow/python/vendored/pythoncapi_compat.h,sha256=bzMnlHTCfjk5DQRIxwytunYh5aQxU3iSElaaDyNnAY8,40900 +pyarrow/src/arrow/python/visibility.h,sha256=hwJw5sGrWJckQkNaAuLe4Tf-VDjQbXknyzNOVgZI3FI,1381 +pyarrow/substrait.py,sha256=ugd_UrjkUIrwSvqFxLl9WkVtBZ2-hcgt5XiSVYvDLnQ,1151 +pyarrow/table.pxi,sha256=Dfujf9nDQ9R--F5cybcUxB126Hu1mBuARWvgOTuFl3o,203868 +pyarrow/tensor.pxi,sha256=CXlMcTRWh_n_FTzIIx8SpHCmYlV0IBA69toQ-3Evs5o,42071 +pyarrow/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +pyarrow/tests/__pycache__/__init__.cpython-310.pyc,, +pyarrow/tests/__pycache__/arrow_16597.cpython-310.pyc,, +pyarrow/tests/__pycache__/arrow_39313.cpython-310.pyc,, +pyarrow/tests/__pycache__/arrow_7980.cpython-310.pyc,, +pyarrow/tests/__pycache__/conftest.cpython-310.pyc,, +pyarrow/tests/__pycache__/pandas_examples.cpython-310.pyc,, +pyarrow/tests/__pycache__/pandas_threaded_import.cpython-310.pyc,, +pyarrow/tests/__pycache__/read_record_batch.cpython-310.pyc,, +pyarrow/tests/__pycache__/strategies.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_acero.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_adhoc_memory_leak.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_array.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_builder.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_cffi.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_compute.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_convert_builtin.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_cpp_internals.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_csv.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_cuda.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_cuda_numba_interop.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_cython.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_dataset.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_dataset_encryption.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_deprecations.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_device.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_dlpack.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_exec_plan.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_extension_type.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_feather.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_flight.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_flight_async.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_fs.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_gandiva.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_gdb.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_io.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_ipc.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_json.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_jvm.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_memory.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_misc.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_orc.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_pandas.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_scalars.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_schema.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_sparse_tensor.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_strategies.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_substrait.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_table.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_tensor.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_types.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_udf.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_util.cpython-310.pyc,, +pyarrow/tests/__pycache__/test_without_numpy.cpython-310.pyc,, +pyarrow/tests/__pycache__/util.cpython-310.pyc,, +pyarrow/tests/__pycache__/wsgi_examples.cpython-310.pyc,, +pyarrow/tests/arrow_16597.py,sha256=DNb41h9E3ITGvAJJu86i5SfsKrwstQJ0E5gT_bpTS_k,1354 +pyarrow/tests/arrow_39313.py,sha256=0pyBixoX38fldTPO1Vwshi_H0XBACrz8esYoL4o71KI,1431 +pyarrow/tests/arrow_7980.py,sha256=tZKb_tRLfxHaosDk9Yu2GLEsJjMaruXD5CKhbK_6Hq8,1094 +pyarrow/tests/bound_function_visit_strings.pyx,sha256=vDEFoNYR8BWNkCntKDuBUT8sXNRBex_5G2bFKogr1Bs,2026 +pyarrow/tests/conftest.py,sha256=PwqCO9vIgMUc2W9gCwcDvEz4hcp2eIYHDZ_fwddhqJ4,9904 +pyarrow/tests/data/feather/v0.17.0.version.2-compression.lz4.feather,sha256=qzcc7Bo4OWBXYsyyKdDJwdTRstMqB1Zz0GiGYtndBnE,594 +pyarrow/tests/data/orc/README.md,sha256=_4X5XszZqQtWAVEz5N1Va4VyyayGQgNDKrcdMX2Ib4s,932 +pyarrow/tests/data/orc/TestOrcFile.emptyFile.jsn.gz,sha256=xLjAXd-3scx3DCyeAsmxTO3dv1cj9KRvYopKe5rQNiI,50 +pyarrow/tests/data/orc/TestOrcFile.emptyFile.orc,sha256=zj0579dQBXhF7JuB-ZphkmQ81ybLo6Ca4zPV4HXoImY,523 +pyarrow/tests/data/orc/TestOrcFile.test1.jsn.gz,sha256=kLxmwMVHtfzpHqBztFjfY_PTCloaXpfHq9DDDszb8Wk,323 +pyarrow/tests/data/orc/TestOrcFile.test1.orc,sha256=A4JxgMCffTkz9-XT1QT1tg2TlYZRRz1g7iIMmqzovqA,1711 +pyarrow/tests/data/orc/TestOrcFile.testDate1900.jsn.gz,sha256=oWf7eBR3ZtOA91OTvdeQJYos1an56msGsJwhGOan3lo,182453 +pyarrow/tests/data/orc/TestOrcFile.testDate1900.orc,sha256=nYsVYhUGGOL80gHj37si_vX0dh8QhIMSeU4sHjNideM,30941 +pyarrow/tests/data/orc/decimal.jsn.gz,sha256=kTEyYdPDAASFUX8Niyry5mRDF-Y-LsrhSAjbu453mvA,19313 +pyarrow/tests/data/orc/decimal.orc,sha256=W5cV2WdLy4OrSTnd_Qv5ntphG4TcB-MyG4UpRFwSxJY,16337 +pyarrow/tests/data/parquet/v0.7.1.all-named-index.parquet,sha256=YPGUXtw-TsOPbiNDieZHobNp3or7nHhAxJGjmIDAyqE,3948 +pyarrow/tests/data/parquet/v0.7.1.column-metadata-handling.parquet,sha256=7sebZgpfdcP37QksT3FhDL6vOA9gR6GBaq44NCVtOYw,2012 +pyarrow/tests/data/parquet/v0.7.1.parquet,sha256=vmdzhIzpBbmRkq3Gjww7KqurfSFNtQuSpSIDeQVmqys,4372 +pyarrow/tests/data/parquet/v0.7.1.some-named-index.parquet,sha256=VGgSjqihCRtdBxlUcfP5s3BSR7aUQKukW-bGgJLf_HY,4008 +pyarrow/tests/extensions.pyx,sha256=05S652zNGxwMFwuyMbP0RP4VNJLSMlzvoxH8iYIvSNk,3054 +pyarrow/tests/interchange/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785 +pyarrow/tests/interchange/__pycache__/__init__.cpython-310.pyc,, +pyarrow/tests/interchange/__pycache__/test_conversion.cpython-310.pyc,, +pyarrow/tests/interchange/__pycache__/test_interchange_spec.cpython-310.pyc,, +pyarrow/tests/interchange/test_conversion.py,sha256=23e5tpKBL-ekA5uWpM6-f6HVPF937Hnzfune0Ty9moo,18609 +pyarrow/tests/interchange/test_interchange_spec.py,sha256=5hwwCG6f7yf72PfUG0iLIk2bARsZU5EJeRjDxSQrkKI,9320 +pyarrow/tests/pandas_examples.py,sha256=RFKCW-Rn0Qz-ncd4pZWWSeUoPq63kemE3lFiVdv2dBs,5115 +pyarrow/tests/pandas_threaded_import.py,sha256=b_ubLr5dj4dWJht9552qc3S3Yt3fQQgaUH6208oZvHg,1429 +pyarrow/tests/parquet/__init__.py,sha256=dKsXU9M-sJyz2wYIuqwsKM9meOlK_qY6qhmQzIvEpCE,931 +pyarrow/tests/parquet/__pycache__/__init__.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/common.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/conftest.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/encryption.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/test_basic.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/test_compliant_nested_type.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/test_data_types.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/test_dataset.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/test_datetime.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/test_encryption.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/test_metadata.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/test_pandas.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/test_parquet_file.cpython-310.pyc,, +pyarrow/tests/parquet/__pycache__/test_parquet_writer.cpython-310.pyc,, +pyarrow/tests/parquet/common.py,sha256=-kckaOVj9P9BvL1vlvyHlsPUtysBoAYVL98Nwc9wmGo,5894 +pyarrow/tests/parquet/conftest.py,sha256=mJNQal0VYsGFhHglhSt-F9CYHy_i8hB8MXaq3SxFBvk,3082 +pyarrow/tests/parquet/encryption.py,sha256=Oi3QbixApvWGoGImiW7PAjR28cTQqlRXZKMI3O7E4UY,2521 +pyarrow/tests/parquet/test_basic.py,sha256=SdLPuZ02NaBUEtpr18SzA90I7pK-WRMM1r3ApbQI5ps,36492 +pyarrow/tests/parquet/test_compliant_nested_type.py,sha256=Lz7tCPrSpv9GrKPMS-eu1LehsCTwz7KdUdCYJ8tF8dE,3901 +pyarrow/tests/parquet/test_data_types.py,sha256=tdYodveHBksDjM7DjSc7x1IEqMAZv0y6z2GsnpDdriM,15778 +pyarrow/tests/parquet/test_dataset.py,sha256=UhjjQGO2kki9Q50zush0VGU3OMXHZncL_3uEQse4Lx8,42218 +pyarrow/tests/parquet/test_datetime.py,sha256=A3ZaRj88u0IrlhCNp2KY_A8txrb7y2pKPgEVvI7e7bU,16398 +pyarrow/tests/parquet/test_encryption.py,sha256=XMVlIcEurlzcPN2rlaNqbdZbGhF9hjz5ZhWY5Bz4Fxo,22099 +pyarrow/tests/parquet/test_metadata.py,sha256=0sbEUEEal4dEczJHk77KzCk3q9P_1JD61Ayw6HBXFzo,27158 +pyarrow/tests/parquet/test_pandas.py,sha256=dXXcaRBZXIt2HervJLC1gCxDLlhxu6MM_M3gxcaV1Rw,22821 +pyarrow/tests/parquet/test_parquet_file.py,sha256=xm5ZUCf5xmpKh7s5nTIrEiis53mfv2NqZWVRiYOTfAg,9909 +pyarrow/tests/parquet/test_parquet_writer.py,sha256=xwedRwRYtw5n_OMhLPGnJurcvlo4ooROsSalYL-ZVCM,11733 +pyarrow/tests/pyarrow_cython_example.pyx,sha256=fx6zT1bUb2-cDnwKoG71K3ozpmrNJ53kKQHHJTExGz8,2115 +pyarrow/tests/read_record_batch.py,sha256=9Y0X0h03hUXwOKZz7jBBZSwgIrjxT-FkWIw6pu38Frc,953 +pyarrow/tests/strategies.py,sha256=ygkKPSV8CM8IMU8uW8d_RuDZEbwyj8bhD0Bv-ZwvaRk,13926 +pyarrow/tests/test_acero.py,sha256=jgSkIAGhrVffShaD0ZAm50sY-f4u9jfjCimK8ezUbbA,15003 +pyarrow/tests/test_adhoc_memory_leak.py,sha256=Pn4PcIbOBRtSJuz9Ar_ocubco0QOMZ-eAE9Bs7Wp4mA,1453 +pyarrow/tests/test_array.py,sha256=p3JPYOvP6zJgNI2vuQ_ah9p5w126d9HRFeHN6Z5q894,139832 +pyarrow/tests/test_builder.py,sha256=zNEcslLwyb40oYbG7lInQcI81QHMKDOzi1zthw1Je7c,2803 +pyarrow/tests/test_cffi.py,sha256=Fbs1dFCxdnvXYLgO5oaxm_h8KV3vefE9jc3nI1JZNxw,26385 +pyarrow/tests/test_compute.py,sha256=ajHKKGCpw92ZgdJl2pfdVF1UW4xGQB3EPELxXt-CnNw,142525 +pyarrow/tests/test_convert_builtin.py,sha256=QTTX4KcmfZ5keLpSjfPnft9Eim4FeYnBpvPDwnOMGP0,80894 +pyarrow/tests/test_cpp_internals.py,sha256=Xg4CUB6zohQkcYG64Lj_Uf2BscI27Vv0JC_CqNkDQuE,2006 +pyarrow/tests/test_csv.py,sha256=GKNYAGis5TsiDJMIu0L6bH2_cIOpWDviRwxCfPN9Pv8,77313 +pyarrow/tests/test_cuda.py,sha256=qCbVbYOokzpEef-e0_Fus36xQR9Y---9MLCYquI3shE,36163 +pyarrow/tests/test_cuda_numba_interop.py,sha256=iHP_FE4sWbsKwNNXRcYnVozp3Wd1o0Mg6BDymx710G4,8794 +pyarrow/tests/test_cython.py,sha256=IJVELKXBD89xoCcxscMfUpwvkk9SL_kNT4cccLjDww4,7115 +pyarrow/tests/test_dataset.py,sha256=nbTfPH338ZqDstL1FuYpD7HefNMvbDi_zPF_zd4lFew,210420 +pyarrow/tests/test_dataset_encryption.py,sha256=mA8ipIlOBSA4eKc6xnRz-IFyM7fu_kIQ5FV2r4vE2rs,7593 +pyarrow/tests/test_deprecations.py,sha256=W_rneq4jC6zqCNoGhBDf1F28Q-0LHI7YKLgtsbV6LHM,891 +pyarrow/tests/test_device.py,sha256=qe9Wiwo-XVazt9pdxyqQJUz6fNR0jTs9CHiyaoppNA4,2550 +pyarrow/tests/test_dlpack.py,sha256=3s23cDst8TaUdum_v4XrWBJ9Ny5q4-b20vJJlHJLI8o,4937 +pyarrow/tests/test_exec_plan.py,sha256=pjOkSaWeqjN6celKxUEH3tBGXLh8kKbmSSsvKOWsbQQ,10096 +pyarrow/tests/test_extension_type.py,sha256=gKukBp0ial_3-iBeLsLIJKN-4ayn1K7P7auil2luH1U,65617 +pyarrow/tests/test_feather.py,sha256=Rw8J4upIZhR0GMe17n84IFGItlBUk9qpHOCWmDWyCuw,25074 +pyarrow/tests/test_flight.py,sha256=9kJlmuwCSzKrilP3UMeA20cyZJwlRB_pqGavbRM0Y7E,87152 +pyarrow/tests/test_flight_async.py,sha256=g_mNqrnNBp7GWNOWZgnVklZcVKV_vvAAChDgcQICNdo,2873 +pyarrow/tests/test_fs.py,sha256=n-RuiqvfK9zWkmmuhHLSZp3v5pRR1f258YKB6R5DsdI,65418 +pyarrow/tests/test_gandiva.py,sha256=AEf9ln-j5MmIMQ0JTQPhnZwbNh82ynSURsWPaKaNing,15623 +pyarrow/tests/test_gdb.py,sha256=OJzMfZtev3YOKJBm2QxnE-q-9-exy2JLhxpiVhY3T_0,44938 +pyarrow/tests/test_io.py,sha256=T9Vdg1rPGjdAp7nd5U9TAc3mN0N4oWvlG-F8TKmMVS4,63768 +pyarrow/tests/test_ipc.py,sha256=JPW2Q3pXKi8Y4adbCkpGZeNjdP8C6Ot1TqapinKeO_Q,42746 +pyarrow/tests/test_json.py,sha256=P60OhNO7MqHWmppL7cKPmvFEYNMj0XdztxiNGxvjhkM,13169 +pyarrow/tests/test_jvm.py,sha256=pIrHUgnDdmwDoLgM2TFvdgfcEJTGtBGsPgzYIRU6jYY,15507 +pyarrow/tests/test_memory.py,sha256=FqCTUSCqZvKx4k-JDY3M83MvxQ15iNdMUbyUxACfS7w,8874 +pyarrow/tests/test_misc.py,sha256=5-P4nWTZXB7ObuCiVwsQgCjNJ8883tZh03EY4aWea4I,7227 +pyarrow/tests/test_orc.py,sha256=oijYMqsxPLYbpEy1NTwqlz-wiTd8aKttaZH6npXNXoY,19321 +pyarrow/tests/test_pandas.py,sha256=_X9K5EQuAMff5vjj0CPlw-Yoa2syFbjXAfWOoZKPPIA,188352 +pyarrow/tests/test_scalars.py,sha256=cKsl6QSB68aKTcHRI_sVXXonA-OgIOrkGjW3iAEIDT4,27654 +pyarrow/tests/test_schema.py,sha256=3ed2GtcKqio7XJMbl9HTN2XxqCLlhiVJBze7VIwxn8Q,21814 +pyarrow/tests/test_sparse_tensor.py,sha256=6Hp-X6PLqcUzTZCRSB-TyaAWR7ZyWf5YsWuZgixmd64,17500 +pyarrow/tests/test_strategies.py,sha256=HEL8T94h8VyukGKNRVAW_RyQ3m36REc2P4q2BQZ_PfY,1811 +pyarrow/tests/test_substrait.py,sha256=yGijuSlKRUndT80QMvuqfCx4135uAI7UjN89RYYiFCI,30634 +pyarrow/tests/test_table.py,sha256=WAYwyPK8jiGWd6H8BKjJsQGcFAsgT0zW-vO5d-7iyo8,120500 +pyarrow/tests/test_tensor.py,sha256=LYSEYGUjtdnsbL0WAir9jFindo-r0bLySiDA1uAXL8E,6643 +pyarrow/tests/test_types.py,sha256=KH-BLjbSuQ17ySb0qr8ZUsYiHNfy_fGHuTsA-Ypr4Og,42056 +pyarrow/tests/test_udf.py,sha256=WA9E5skUqh7uMr_zH3rQ11LRx0SK2G3WO8HjVHGWyQY,29792 +pyarrow/tests/test_util.py,sha256=ozTlooHBMOP3nbX5b3dG2aanrXwxXHx1giicm0QQyPM,5030 +pyarrow/tests/test_without_numpy.py,sha256=ysbB-jML318I04ViQT4Ok7iMg1cI-NU8kguPu-FTSl4,1855 +pyarrow/tests/util.py,sha256=YeH8RovBtKY4L1SJqcOOObEZx0Yf6HSpkkq4xJdKL5U,13275 +pyarrow/tests/wsgi_examples.py,sha256=vQIDb5989sRVLsELw-fRHhfX-dE96sTl5J2lEuEKup8,1348 +pyarrow/types.pxi,sha256=dPCKGp91crrmtwOfkotcsh0QNVPrmOdQQVqOuaHbCao,157764 +pyarrow/types.py,sha256=Woixb8A_OzBNtolWwwFGhbEWn10gavaB7S0wGMoFakQ,7240 +pyarrow/util.py,sha256=W0LXUR7nsrA5N-l3THD283bxCibS0sM1q6WLcfbFFz8,7970 +pyarrow/vendored/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785 +pyarrow/vendored/__pycache__/__init__.cpython-310.pyc,, +pyarrow/vendored/__pycache__/docscrape.cpython-310.pyc,, +pyarrow/vendored/__pycache__/version.cpython-310.pyc,, +pyarrow/vendored/docscrape.py,sha256=phTjwuzoO5hB88QerZk3uGu9c5OrZwjFzI7vEIIbCUQ,22975 +pyarrow/vendored/version.py,sha256=5-Vo4Q3kPJrm1DSGusnMlTxuA8ynI4hAryApBd6MnpQ,14345 diff --git a/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/REQUESTED b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/WHEEL b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..399e013bac7e769a07d26312e6300b5433007a6b --- /dev/null +++ b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (72.1.0) +Root-Is-Purelib: false +Tag: cp310-cp310-manylinux_2_28_x86_64 + diff --git a/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/top_level.txt b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..652a7f20a026b7151711b81e752207ae1bcfce96 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/pyarrow-18.1.0.dist-info/top_level.txt @@ -0,0 +1,2 @@ +__dummy__ +pyarrow