Add files using upload-large-folder tool

.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

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.

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)

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

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: ...

vllm/lib/python3.10/site-packages/contourpy/_version.py

@@ -0,0 +1 @@
+__version__ = "1.3.1"

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)]

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

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]

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]

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

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}")

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

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"]

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",
+    )

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))

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]

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

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)

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

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

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 "<VariationAxis '{}' ('{}') [{}, {}, {}]>".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 "<VariationInstance '{}' {}>".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)

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')]

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")

vllm/lib/python3.10/site-packages/freetype/__pyinstaller/tests/conftest.py

@@ -0,0 +1 @@
+from PyInstaller.utils.conftest import *

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!"
+        """
+    )

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 *

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)

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)

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)

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

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