Add files using upload-large-folder tool

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

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

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

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

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

venv/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

venv/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]

venv/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]

venv/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

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

venv/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

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

venv/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-dfa9bu3d/bin/python",
+
+        # Package versions
+        contourpy_version="1.3.2",
+        meson_version="1.7.2",
+        mesonpy_version="0.17.1",
+        pybind11_version="2.13.6",
+
+        # Misc meson settings
+        meson_backend="ninja",
+        build_dir=r"/project/.mesonpy-0roiogjz/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-0roiogjz/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",
+    )

venv/lib/python3.10/site-packages/contourpy/util/bokeh_renderer.py

@@ -0,0 +1,339 @@
+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.core.enums import OutputBackendType
+    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: OutputBackendType = "svg" if self._want_svg else "canvas"
+        for _ in range(nfigures):
+            fig = figure(output_backend=backend)
+            fig.xgrid.visible = False  # type: ignore[attr-defined]
+            fig.ygrid.visible = False  # type: ignore[attr-defined]
+            self._figures.append(fig)
+            if not show_frame:
+                fig.outline_line_color = None
+                fig.axis.visible = False  # type: ignore[attr-defined]
+
+        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)  # type: ignore[arg-type]
+
+    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:
+            assert ys 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
+                fig.border_fill_color = None
+
+        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
+        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):
+                label = Label(x=x[j, i], y=y[j, i], text=f"{z[j, i]:{fmt}}", **kwargs)  # type: ignore[arg-type]
+                fig.add_layout(label)
+        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))  # type: ignore[arg-type]

venv/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]

venv/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

venv/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], dtype=np.float64)
+                    yy = np.mean(y[j:j+2, i:i+2], dtype=np.float64)
+                    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)

venv/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

venv/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

venv/lib/python3.10/site-packages/filelock-3.20.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/lib/python3.10/site-packages/filelock-3.20.0.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: filelock
+Version: 3.20.0
+Summary: A platform independent file lock.
+Project-URL: Documentation, https://py-filelock.readthedocs.io
+Project-URL: Homepage, https://github.com/tox-dev/py-filelock
+Project-URL: Source, https://github.com/tox-dev/py-filelock
+Project-URL: Tracker, https://github.com/tox-dev/py-filelock/issues
+Maintainer-email: Bernát Gábor <gaborjbernat@gmail.com>
+License-Expression: Unlicense
+License-File: LICENSE
+Keywords: application,cache,directory,log,user
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# filelock
+
+[![PyPI](https://img.shields.io/pypi/v/filelock)](https://pypi.org/project/filelock/)
+[![Supported Python
+versions](https://img.shields.io/pypi/pyversions/filelock.svg)](https://pypi.org/project/filelock/)
+[![Documentation
+status](https://readthedocs.org/projects/py-filelock/badge/?version=latest)](https://py-filelock.readthedocs.io/en/latest/?badge=latest)
+[![Code style:
+black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Downloads](https://static.pepy.tech/badge/filelock/month)](https://pepy.tech/project/filelock)
+[![check](https://github.com/tox-dev/py-filelock/actions/workflows/check.yaml/badge.svg)](https://github.com/tox-dev/py-filelock/actions/workflows/check.yaml)
+
+For more information checkout the [official documentation](https://py-filelock.readthedocs.io/en/latest/index.html).

venv/lib/python3.10/site-packages/filelock-3.20.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+filelock-3.20.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+filelock-3.20.0.dist-info/METADATA,sha256=gIghqdcbGNywxw52pN02_a9OxFqzhjA8v-9GsDWtNog,2110
+filelock-3.20.0.dist-info/RECORD,,
+filelock-3.20.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filelock-3.20.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+filelock-3.20.0.dist-info/licenses/LICENSE,sha256=iNm062BXnBkew5HKBMFhMFctfu3EqG2qWL8oxuFMm80,1210
+filelock/__init__.py,sha256=_t_-OAGXo_qyPa9lNQ1YnzVYEvSW3I0onPqzpomsVVg,1769
+filelock/__pycache__/__init__.cpython-310.pyc,,
+filelock/__pycache__/_api.cpython-310.pyc,,
+filelock/__pycache__/_error.cpython-310.pyc,,
+filelock/__pycache__/_soft.cpython-310.pyc,,
+filelock/__pycache__/_unix.cpython-310.pyc,,
+filelock/__pycache__/_util.cpython-310.pyc,,
+filelock/__pycache__/_windows.cpython-310.pyc,,
+filelock/__pycache__/asyncio.cpython-310.pyc,,
+filelock/__pycache__/version.cpython-310.pyc,,
+filelock/_api.py,sha256=2aATBeJ3-jtMj5OSm7EE539iNaTBsf13KXtcBMoi8oM,14545
+filelock/_error.py,sha256=-5jMcjTu60YAvAO1UbqDD1GIEjVkwr8xCFwDBtMeYDg,787
+filelock/_soft.py,sha256=haqtc_TB_KJbYv2a8iuEAclKuM4fMG1vTcp28sK919c,1711
+filelock/_unix.py,sha256=eGOs4gDgZ-5fGnJUz-OkJDeZkAMzgvYcD8hVD6XH7e4,2351
+filelock/_util.py,sha256=QHBoNFIYfbAThhotH3Q8E2acFc84wpG49-T-uu017ZE,1715
+filelock/_windows.py,sha256=8k4XIBl_zZVfGC2gz0kEr8DZBvpNa8wdU9qeM1YrBb8,2179
+filelock/asyncio.py,sha256=dSLe6XZSECFOgsVpcQUSh5Y5zAHxHGPu_tfpPX9I45k,12514
+filelock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filelock/version.py,sha256=AW5MeEjK4TaQWWJrGb_AlBw8PlmFoIcn7GodG_AVSOM,706

venv/lib/python3.10/site-packages/filelock-3.20.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

venv/lib/python3.10/site-packages/filelock-3.20.0.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org>

venv/lib/python3.10/site-packages/fontTools/__init__.py

@@ -0,0 +1,8 @@
+import logging
+from fontTools.misc.loggingTools import configLogger
+
+log = logging.getLogger(__name__)
+
+version = __version__ = "4.60.1"
+
+__all__ = ["version", "log", "configLogger"]

venv/lib/python3.10/site-packages/fontTools/__main__.py

@@ -0,0 +1,35 @@
+import sys
+
+
+def main(args=None):
+    if args is None:
+        args = sys.argv[1:]
+
+    # TODO Handle library-wide options. Eg.:
+    # --unicodedata
+    # --verbose / other logging stuff
+
+    # TODO Allow a way to run arbitrary modules? Useful for setting
+    # library-wide options and calling another library. Eg.:
+    #
+    #   $ fonttools --unicodedata=... fontmake ...
+    #
+    # This allows for a git-like command where thirdparty commands
+    # can be added.  Should we just try importing the fonttools
+    # module first and try without if it fails?
+
+    if len(sys.argv) < 2:
+        sys.argv.append("help")
+    if sys.argv[1] == "-h" or sys.argv[1] == "--help":
+        sys.argv[1] = "help"
+    mod = "fontTools." + sys.argv[1]
+    sys.argv[1] = sys.argv[0] + " " + sys.argv[1]
+    del sys.argv[0]
+
+    import runpy
+
+    runpy.run_module(mod, run_name="__main__")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

venv/lib/python3.10/site-packages/fontTools/afmLib.py

@@ -0,0 +1,439 @@
+"""Module for reading and writing AFM (Adobe Font Metrics) files.
+
+Note that this has been designed to read in AFM files generated by Fontographer
+and has not been tested on many other files. In particular, it does not
+implement the whole Adobe AFM specification [#f1]_ but, it should read most
+"common" AFM files.
+
+Here is an example of using `afmLib` to read, modify and write an AFM file:
+
+	>>> from fontTools.afmLib import AFM
+	>>> f = AFM("Tests/afmLib/data/TestAFM.afm")
+	>>>
+	>>> # Accessing a pair gets you the kern value
+	>>> f[("V","A")]
+	-60
+	>>>
+	>>> # Accessing a glyph name gets you metrics
+	>>> f["A"]
+	(65, 668, (8, -25, 660, 666))
+	>>> # (charnum, width, bounding box)
+	>>>
+	>>> # Accessing an attribute gets you metadata
+	>>> f.FontName
+	'TestFont-Regular'
+	>>> f.FamilyName
+	'TestFont'
+	>>> f.Weight
+	'Regular'
+	>>> f.XHeight
+	500
+	>>> f.Ascender
+	750
+	>>>
+	>>> # Attributes and items can also be set
+	>>> f[("A","V")] = -150 # Tighten kerning
+	>>> f.FontName = "TestFont Squished"
+	>>>
+	>>> # And the font written out again (remove the # in front)
+	>>> #f.write("testfont-squished.afm")
+
+.. rubric:: Footnotes
+
+.. [#f1] `Adobe Technote 5004 <https://www.adobe.com/content/dam/acom/en/devnet/font/pdfs/5004.AFM_Spec.pdf>`_,
+   Adobe Font Metrics File Format Specification.
+
+"""
+
+import re
+
+# every single line starts with a "word"
+identifierRE = re.compile(r"^([A-Za-z]+).*")
+
+# regular expression to parse char lines
+charRE = re.compile(
+    r"(-?\d+)"  # charnum
+    r"\s*;\s*WX\s+"  # ; WX
+    r"(-?\d+)"  # width
+    r"\s*;\s*N\s+"  # ; N
+    r"([.A-Za-z0-9_]+)"  # charname
+    r"\s*;\s*B\s+"  # ; B
+    r"(-?\d+)"  # left
+    r"\s+"
+    r"(-?\d+)"  # bottom
+    r"\s+"
+    r"(-?\d+)"  # right
+    r"\s+"
+    r"(-?\d+)"  # top
+    r"\s*;\s*"  # ;
+)
+
+# regular expression to parse kerning lines
+kernRE = re.compile(
+    r"([.A-Za-z0-9_]+)"  # leftchar
+    r"\s+"
+    r"([.A-Za-z0-9_]+)"  # rightchar
+    r"\s+"
+    r"(-?\d+)"  # value
+    r"\s*"
+)
+
+# regular expressions to parse composite info lines of the form:
+# Aacute 2 ; PCC A 0 0 ; PCC acute 182 211 ;
+compositeRE = re.compile(
+    r"([.A-Za-z0-9_]+)"  # char name
+    r"\s+"
+    r"(\d+)"  # number of parts
+    r"\s*;\s*"
+)
+componentRE = re.compile(
+    r"PCC\s+"  # PPC
+    r"([.A-Za-z0-9_]+)"  # base char name
+    r"\s+"
+    r"(-?\d+)"  # x offset
+    r"\s+"
+    r"(-?\d+)"  # y offset
+    r"\s*;\s*"
+)
+
+preferredAttributeOrder = [
+    "FontName",
+    "FullName",
+    "FamilyName",
+    "Weight",
+    "ItalicAngle",
+    "IsFixedPitch",
+    "FontBBox",
+    "UnderlinePosition",
+    "UnderlineThickness",
+    "Version",
+    "Notice",
+    "EncodingScheme",
+    "CapHeight",
+    "XHeight",
+    "Ascender",
+    "Descender",
+]
+
+
+class error(Exception):
+    pass
+
+
+class AFM(object):
+    _attrs = None
+
+    _keywords = [
+        "StartFontMetrics",
+        "EndFontMetrics",
+        "StartCharMetrics",
+        "EndCharMetrics",
+        "StartKernData",
+        "StartKernPairs",
+        "EndKernPairs",
+        "EndKernData",
+        "StartComposites",
+        "EndComposites",
+    ]
+
+    def __init__(self, path=None):
+        """AFM file reader.
+
+        Instantiating an object with a path name will cause the file to be opened,
+        read, and parsed. Alternatively the path can be left unspecified, and a
+        file can be parsed later with the :meth:`read` method."""
+        self._attrs = {}
+        self._chars = {}
+        self._kerning = {}
+        self._index = {}
+        self._comments = []
+        self._composites = {}
+        if path is not None:
+            self.read(path)
+
+    def read(self, path):
+        """Opens, reads and parses a file."""
+        lines = readlines(path)
+        for line in lines:
+            if not line.strip():
+                continue
+            m = identifierRE.match(line)
+            if m is None:
+                raise error("syntax error in AFM file: " + repr(line))
+
+            pos = m.regs[1][1]
+            word = line[:pos]
+            rest = line[pos:].strip()
+            if word in self._keywords:
+                continue
+            if word == "C":
+                self.parsechar(rest)
+            elif word == "KPX":
+                self.parsekernpair(rest)
+            elif word == "CC":
+                self.parsecomposite(rest)
+            else:
+                self.parseattr(word, rest)
+
+    def parsechar(self, rest):
+        m = charRE.match(rest)
+        if m is None:
+            raise error("syntax error in AFM file: " + repr(rest))
+        things = []
+        for fr, to in m.regs[1:]:
+            things.append(rest[fr:to])
+        charname = things[2]
+        del things[2]
+        charnum, width, l, b, r, t = (int(thing) for thing in things)
+        self._chars[charname] = charnum, width, (l, b, r, t)
+
+    def parsekernpair(self, rest):
+        m = kernRE.match(rest)
+        if m is None:
+            raise error("syntax error in AFM file: " + repr(rest))
+        things = []
+        for fr, to in m.regs[1:]:
+            things.append(rest[fr:to])
+        leftchar, rightchar, value = things
+        value = int(value)
+        self._kerning[(leftchar, rightchar)] = value
+
+    def parseattr(self, word, rest):
+        if word == "FontBBox":
+            l, b, r, t = [int(thing) for thing in rest.split()]
+            self._attrs[word] = l, b, r, t
+        elif word == "Comment":
+            self._comments.append(rest)
+        else:
+            try:
+                value = int(rest)
+            except (ValueError, OverflowError):
+                self._attrs[word] = rest
+            else:
+                self._attrs[word] = value
+
+    def parsecomposite(self, rest):
+        m = compositeRE.match(rest)
+        if m is None:
+            raise error("syntax error in AFM file: " + repr(rest))
+        charname = m.group(1)
+        ncomponents = int(m.group(2))
+        rest = rest[m.regs[0][1] :]
+        components = []
+        while True:
+            m = componentRE.match(rest)
+            if m is None:
+                raise error("syntax error in AFM file: " + repr(rest))
+            basechar = m.group(1)
+            xoffset = int(m.group(2))
+            yoffset = int(m.group(3))
+            components.append((basechar, xoffset, yoffset))
+            rest = rest[m.regs[0][1] :]
+            if not rest:
+                break
+        assert len(components) == ncomponents
+        self._composites[charname] = components
+
+    def write(self, path, sep="\r"):
+        """Writes out an AFM font to the given path."""
+        import time
+
+        lines = [
+            "StartFontMetrics 2.0",
+            "Comment Generated by afmLib; at %s"
+            % (time.strftime("%m/%d/%Y %H:%M:%S", time.localtime(time.time()))),
+        ]
+
+        # write comments, assuming (possibly wrongly!) they should
+        # all appear at the top
+        for comment in self._comments:
+            lines.append("Comment " + comment)
+
+        # write attributes, first the ones we know about, in
+        # a preferred order
+        attrs = self._attrs
+        for attr in preferredAttributeOrder:
+            if attr in attrs:
+                value = attrs[attr]
+                if attr == "FontBBox":
+                    value = "%s %s %s %s" % value
+                lines.append(attr + " " + str(value))
+        # then write the attributes we don't know about,
+        # in alphabetical order
+        items = sorted(attrs.items())
+        for attr, value in items:
+            if attr in preferredAttributeOrder:
+                continue
+            lines.append(attr + " " + str(value))
+
+        # write char metrics
+        lines.append("StartCharMetrics " + repr(len(self._chars)))
+        items = [
+            (charnum, (charname, width, box))
+            for charname, (charnum, width, box) in self._chars.items()
+        ]
+
+        def myKey(a):
+            """Custom key function to make sure unencoded chars (-1)
+            end up at the end of the list after sorting."""
+            if a[0] == -1:
+                a = (0xFFFF,) + a[1:]  # 0xffff is an arbitrary large number
+            return a
+
+        items.sort(key=myKey)
+
+        for charnum, (charname, width, (l, b, r, t)) in items:
+            lines.append(
+                "C %d ; WX %d ; N %s ; B %d %d %d %d ;"
+                % (charnum, width, charname, l, b, r, t)
+            )
+        lines.append("EndCharMetrics")
+
+        # write kerning info
+        lines.append("StartKernData")
+        lines.append("StartKernPairs " + repr(len(self._kerning)))
+        items = sorted(self._kerning.items())
+        for (leftchar, rightchar), value in items:
+            lines.append("KPX %s %s %d" % (leftchar, rightchar, value))
+        lines.append("EndKernPairs")
+        lines.append("EndKernData")
+
+        if self._composites:
+            composites = sorted(self._composites.items())
+            lines.append("StartComposites %s" % len(self._composites))
+            for charname, components in composites:
+                line = "CC %s %s ;" % (charname, len(components))
+                for basechar, xoffset, yoffset in components:
+                    line = line + " PCC %s %s %s ;" % (basechar, xoffset, yoffset)
+                lines.append(line)
+            lines.append("EndComposites")
+
+        lines.append("EndFontMetrics")
+
+        writelines(path, lines, sep)
+
+    def has_kernpair(self, pair):
+        """Returns `True` if the given glyph pair (specified as a tuple) exists
+        in the kerning dictionary."""
+        return pair in self._kerning
+
+    def kernpairs(self):
+        """Returns a list of all kern pairs in the kerning dictionary."""
+        return list(self._kerning.keys())
+
+    def has_char(self, char):
+        """Returns `True` if the given glyph exists in the font."""
+        return char in self._chars
+
+    def chars(self):
+        """Returns a list of all glyph names in the font."""
+        return list(self._chars.keys())
+
+    def comments(self):
+        """Returns all comments from the file."""
+        return self._comments
+
+    def addComment(self, comment):
+        """Adds a new comment to the file."""
+        self._comments.append(comment)
+
+    def addComposite(self, glyphName, components):
+        """Specifies that the glyph `glyphName` is made up of the given components.
+        The components list should be of the following form::
+
+                [
+                        (glyphname, xOffset, yOffset),
+                        ...
+                ]
+
+        """
+        self._composites[glyphName] = components
+
+    def __getattr__(self, attr):
+        if attr in self._attrs:
+            return self._attrs[attr]
+        else:
+            raise AttributeError(attr)
+
+    def __setattr__(self, attr, value):
+        # all attrs *not* starting with "_" are consider to be AFM keywords
+        if attr[:1] == "_":
+            self.__dict__[attr] = value
+        else:
+            self._attrs[attr] = value
+
+    def __delattr__(self, attr):
+        # all attrs *not* starting with "_" are consider to be AFM keywords
+        if attr[:1] == "_":
+            try:
+                del self.__dict__[attr]
+            except KeyError:
+                raise AttributeError(attr)
+        else:
+            try:
+                del self._attrs[attr]
+            except KeyError:
+                raise AttributeError(attr)
+
+    def __getitem__(self, key):
+        if isinstance(key, tuple):
+            # key is a tuple, return the kernpair
+            return self._kerning[key]
+        else:
+            # return the metrics instead
+            return self._chars[key]
+
+    def __setitem__(self, key, value):
+        if isinstance(key, tuple):
+            # key is a tuple, set kernpair
+            self._kerning[key] = value
+        else:
+            # set char metrics
+            self._chars[key] = value
+
+    def __delitem__(self, key):
+        if isinstance(key, tuple):
+            # key is a tuple, del kernpair
+            del self._kerning[key]
+        else:
+            # del char metrics
+            del self._chars[key]
+
+    def __repr__(self):
+        if hasattr(self, "FullName"):
+            return "<AFM object for %s>" % self.FullName
+        else:
+            return "<AFM object at %x>" % id(self)
+
+
+def readlines(path):
+    with open(path, "r", encoding="ascii") as f:
+        data = f.read()
+    return data.splitlines()
+
+
+def writelines(path, lines, sep="\r"):
+    with open(path, "w", encoding="ascii", newline=sep) as f:
+        f.write("\n".join(lines) + "\n")
+
+
+if __name__ == "__main__":
+    import EasyDialogs
+
+    path = EasyDialogs.AskFileForOpen()
+    if path:
+        afm = AFM(path)
+        char = "A"
+        if afm.has_char(char):
+            print(afm[char])  # print charnum, width and boundingbox
+        pair = ("A", "V")
+        if afm.has_kernpair(pair):
+            print(afm[pair])  # print kerning value for pair
+        print(afm.Version)  # various other afm entries have become attributes
+        print(afm.Weight)
+        # afm.comments() returns a list of all Comment lines found in the AFM
+        print(afm.comments())
+        # print afm.chars()
+        # print afm.kernpairs()
+        print(afm)
+        afm.write(path + ".muck")

venv/lib/python3.10/site-packages/fontTools/annotations.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Iterable, Optional, TypeVar, Union
+from collections.abc import Callable, Sequence
+from fontTools.misc.filesystem._base import FS
+from os import PathLike
+from xml.etree.ElementTree import Element as ElementTreeElement
+
+if TYPE_CHECKING:
+    from fontTools.ufoLib import UFOFormatVersion
+    from fontTools.ufoLib.glifLib import GLIFFormatVersion
+    from lxml.etree import _Element as LxmlElement
+
+
+T = TypeVar("T")  # Generic type
+K = TypeVar("K")  # Generic dict key type
+V = TypeVar("V")  # Generic dict value type
+
+GlyphNameToFileNameFunc = Optional[Callable[[str, set[str]], str]]
+ElementType = Union[ElementTreeElement, "LxmlElement"]
+FormatVersion = Union[int, tuple[int, int]]
+FormatVersions = Optional[Iterable[FormatVersion]]
+GLIFFormatVersionInput = Optional[Union[int, tuple[int, int], "GLIFFormatVersion"]]
+UFOFormatVersionInput = Optional[Union[int, tuple[int, int], "UFOFormatVersion"]]
+IntFloat = Union[int, float]
+KerningPair = tuple[str, str]
+KerningDict = dict[KerningPair, IntFloat]
+KerningGroups = dict[str, Sequence[str]]
+KerningNested = dict[str, dict[str, IntFloat]]
+PathStr = Union[str, PathLike[str]]
+PathOrFS = Union[PathStr, FS]

venv/lib/python3.10/site-packages/fontTools/cffLib/CFF2ToCFF.py

@@ -0,0 +1,233 @@
+"""CFF2 to CFF converter."""
+
+from fontTools.ttLib import TTFont, newTable
+from fontTools.misc.cliTools import makeOutputFileName
+from fontTools.misc.psCharStrings import T2StackUseExtractor
+from fontTools.cffLib import (
+    TopDictIndex,
+    buildOrder,
+    buildDefaults,
+    topDictOperators,
+    privateDictOperators,
+    FDSelect,
+)
+from .transforms import desubroutinizeCharString
+from .specializer import specializeProgram
+from .width import optimizeWidths
+from collections import defaultdict
+import logging
+
+
+__all__ = ["convertCFF2ToCFF", "main"]
+
+
+log = logging.getLogger("fontTools.cffLib")
+
+
+def _convertCFF2ToCFF(cff, otFont):
+    """Converts this object from CFF2 format to CFF format. This conversion
+    is done 'in-place'. The conversion cannot be reversed.
+
+    The CFF2 font cannot be variable. (TODO Accept those and convert to the
+    default instance?)
+
+    This assumes a decompiled CFF2 table. (i.e. that the object has been
+    filled via :meth:`decompile` and e.g. not loaded from XML.)"""
+
+    cff.major = 1
+
+    topDictData = TopDictIndex(None)
+    for item in cff.topDictIndex:
+        # Iterate over, such that all are decompiled
+        item.cff2GetGlyphOrder = None
+        topDictData.append(item)
+    cff.topDictIndex = topDictData
+    topDict = topDictData[0]
+
+    if hasattr(topDict, "VarStore"):
+        raise ValueError("Variable CFF2 font cannot be converted to CFF format.")
+
+    opOrder = buildOrder(topDictOperators)
+    topDict.order = opOrder
+    for key in topDict.rawDict.keys():
+        if key not in opOrder:
+            del topDict.rawDict[key]
+            if hasattr(topDict, key):
+                delattr(topDict, key)
+
+    charStrings = topDict.CharStrings
+
+    fdArray = topDict.FDArray
+    if not hasattr(topDict, "FDSelect"):
+        # FDSelect is optional in CFF2, but required in CFF.
+        fdSelect = topDict.FDSelect = FDSelect()
+        fdSelect.gidArray = [0] * len(charStrings.charStrings)
+
+    defaults = buildDefaults(privateDictOperators)
+    order = buildOrder(privateDictOperators)
+    for fd in fdArray:
+        fd.setCFF2(False)
+        privateDict = fd.Private
+        privateDict.order = order
+        for key in order:
+            if key not in privateDict.rawDict and key in defaults:
+                privateDict.rawDict[key] = defaults[key]
+        for key in privateDict.rawDict.keys():
+            if key not in order:
+                del privateDict.rawDict[key]
+                if hasattr(privateDict, key):
+                    delattr(privateDict, key)
+
+    # Add ending operators
+    for cs in charStrings.values():
+        cs.decompile()
+        cs.program.append("endchar")
+    for subrSets in [cff.GlobalSubrs] + [
+        getattr(fd.Private, "Subrs", []) for fd in fdArray
+    ]:
+        for cs in subrSets:
+            cs.program.append("return")
+
+    # Add (optimal) width to CharStrings that need it.
+    widths = defaultdict(list)
+    metrics = otFont["hmtx"].metrics
+    for glyphName in charStrings.keys():
+        cs, fdIndex = charStrings.getItemAndSelector(glyphName)
+        if fdIndex == None:
+            fdIndex = 0
+        widths[fdIndex].append(metrics[glyphName][0])
+    for fdIndex, widthList in widths.items():
+        bestDefault, bestNominal = optimizeWidths(widthList)
+        private = fdArray[fdIndex].Private
+        private.defaultWidthX = bestDefault
+        private.nominalWidthX = bestNominal
+    for glyphName in charStrings.keys():
+        cs, fdIndex = charStrings.getItemAndSelector(glyphName)
+        if fdIndex == None:
+            fdIndex = 0
+        private = fdArray[fdIndex].Private
+        width = metrics[glyphName][0]
+        if width != private.defaultWidthX:
+            cs.program.insert(0, width - private.nominalWidthX)
+
+    # Handle stack use since stack-depth is lower in CFF than in CFF2.
+    for glyphName in charStrings.keys():
+        cs, fdIndex = charStrings.getItemAndSelector(glyphName)
+        if fdIndex is None:
+            fdIndex = 0
+        private = fdArray[fdIndex].Private
+        extractor = T2StackUseExtractor(
+            getattr(private, "Subrs", []), cff.GlobalSubrs, private=private
+        )
+        stackUse = extractor.execute(cs)
+        if stackUse > 48:  # CFF stack depth is 48
+            desubroutinizeCharString(cs)
+            cs.program = specializeProgram(cs.program)
+
+    # Unused subroutines are still in CFF2 (ie. lacking 'return' operator)
+    # because they were not decompiled when we added the 'return'.
+    # Moreover, some used subroutines may have become unused after the
+    # stack-use fixup. So we remove all unused subroutines now.
+    cff.remove_unused_subroutines()
+
+    mapping = {
+        name: ("cid" + str(n).zfill(5) if n else ".notdef")
+        for n, name in enumerate(topDict.charset)
+    }
+    topDict.charset = [
+        "cid" + str(n).zfill(5) if n else ".notdef" for n in range(len(topDict.charset))
+    ]
+    charStrings.charStrings = {
+        mapping[name]: v for name, v in charStrings.charStrings.items()
+    }
+
+    topDict.ROS = ("Adobe", "Identity", 0)
+
+
+def convertCFF2ToCFF(font, *, updatePostTable=True):
+    if "CFF2" not in font:
+        raise ValueError("Input font does not contain a CFF2 table.")
+    cff = font["CFF2"].cff
+    _convertCFF2ToCFF(cff, font)
+    del font["CFF2"]
+    table = font["CFF "] = newTable("CFF ")
+    table.cff = cff
+
+    if updatePostTable and "post" in font:
+        # Only version supported for fonts with CFF table is 0x00030000 not 0x20000
+        post = font["post"]
+        if post.formatType == 2.0:
+            post.formatType = 3.0
+
+
+def main(args=None):
+    """Convert CFF2 OTF font to CFF OTF font"""
+    if args is None:
+        import sys
+
+        args = sys.argv[1:]
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools cffLib.CFF2ToCFF",
+        description="Convert a non-variable CFF2 font to CFF.",
+    )
+    parser.add_argument(
+        "input", metavar="INPUT.ttf", help="Input OTF file with CFF table."
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        metavar="OUTPUT.ttf",
+        default=None,
+        help="Output instance OTF file (default: INPUT-CFF2.ttf).",
+    )
+    parser.add_argument(
+        "--no-recalc-timestamp",
+        dest="recalc_timestamp",
+        action="store_false",
+        help="Don't set the output font's timestamp to the current time.",
+    )
+    loggingGroup = parser.add_mutually_exclusive_group(required=False)
+    loggingGroup.add_argument(
+        "-v", "--verbose", action="store_true", help="Run more verbosely."
+    )
+    loggingGroup.add_argument(
+        "-q", "--quiet", action="store_true", help="Turn verbosity off."
+    )
+    options = parser.parse_args(args)
+
+    from fontTools import configLogger
+
+    configLogger(
+        level=("DEBUG" if options.verbose else "ERROR" if options.quiet else "INFO")
+    )
+
+    import os
+
+    infile = options.input
+    if not os.path.isfile(infile):
+        parser.error("No such file '{}'".format(infile))
+
+    outfile = (
+        makeOutputFileName(infile, overWrite=True, suffix="-CFF")
+        if not options.output
+        else options.output
+    )
+
+    font = TTFont(infile, recalcTimestamp=options.recalc_timestamp, recalcBBoxes=False)
+
+    convertCFF2ToCFF(font)
+
+    log.info(
+        "Saving %s",
+        outfile,
+    )
+    font.save(outfile)
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main(sys.argv[1:]))

venv/lib/python3.10/site-packages/fontTools/cffLib/CFFToCFF2.py

@@ -0,0 +1,305 @@
+"""CFF to CFF2 converter."""
+
+from fontTools.ttLib import TTFont, newTable
+from fontTools.misc.cliTools import makeOutputFileName
+from fontTools.misc.psCharStrings import T2WidthExtractor
+from fontTools.cffLib import (
+    TopDictIndex,
+    FDArrayIndex,
+    FontDict,
+    buildOrder,
+    topDictOperators,
+    privateDictOperators,
+    topDictOperators2,
+    privateDictOperators2,
+)
+from io import BytesIO
+import logging
+
+__all__ = ["convertCFFToCFF2", "main"]
+
+
+log = logging.getLogger("fontTools.cffLib")
+
+
+class _NominalWidthUsedError(Exception):
+    def __add__(self, other):
+        raise self
+
+    def __radd__(self, other):
+        raise self
+
+
+def _convertCFFToCFF2(cff, otFont):
+    """Converts this object from CFF format to CFF2 format. This conversion
+    is done 'in-place'. The conversion cannot be reversed.
+
+    This assumes a decompiled CFF table. (i.e. that the object has been
+    filled via :meth:`decompile` and e.g. not loaded from XML.)"""
+
+    # Clean up T2CharStrings
+
+    topDict = cff.topDictIndex[0]
+    fdArray = topDict.FDArray if hasattr(topDict, "FDArray") else None
+    charStrings = topDict.CharStrings
+    globalSubrs = cff.GlobalSubrs
+    localSubrs = (
+        [getattr(fd.Private, "Subrs", []) for fd in fdArray]
+        if fdArray
+        else (
+            [topDict.Private.Subrs]
+            if hasattr(topDict, "Private") and hasattr(topDict.Private, "Subrs")
+            else []
+        )
+    )
+
+    for glyphName in charStrings.keys():
+        cs, fdIndex = charStrings.getItemAndSelector(glyphName)
+        cs.decompile()
+
+    # Clean up subroutines first
+    for subrs in [globalSubrs] + localSubrs:
+        for subr in subrs:
+            program = subr.program
+            i = j = len(program)
+            try:
+                i = program.index("return")
+            except ValueError:
+                pass
+            try:
+                j = program.index("endchar")
+            except ValueError:
+                pass
+            program[min(i, j) :] = []
+
+    # Clean up glyph charstrings
+    removeUnusedSubrs = False
+    nominalWidthXError = _NominalWidthUsedError()
+    for glyphName in charStrings.keys():
+        cs, fdIndex = charStrings.getItemAndSelector(glyphName)
+        program = cs.program
+
+        thisLocalSubrs = (
+            localSubrs[fdIndex]
+            if fdIndex is not None
+            else (
+                getattr(topDict.Private, "Subrs", [])
+                if hasattr(topDict, "Private")
+                else []
+            )
+        )
+
+        # Intentionally use custom type for nominalWidthX, such that any
+        # CharString that has an explicit width encoded will throw back to us.
+        extractor = T2WidthExtractor(
+            thisLocalSubrs,
+            globalSubrs,
+            nominalWidthXError,
+            0,
+        )
+        try:
+            extractor.execute(cs)
+        except _NominalWidthUsedError:
+            # Program has explicit width. We want to drop it, but can't
+            # just pop the first number since it may be a subroutine call.
+            # Instead, when seeing that, we embed the subroutine and recurse.
+            # If this ever happened, we later prune unused subroutines.
+            while len(program) >= 2 and program[1] in ["callsubr", "callgsubr"]:
+                removeUnusedSubrs = True
+                subrNumber = program.pop(0)
+                assert isinstance(subrNumber, int), subrNumber
+                op = program.pop(0)
+                bias = extractor.localBias if op == "callsubr" else extractor.globalBias
+                subrNumber += bias
+                subrSet = thisLocalSubrs if op == "callsubr" else globalSubrs
+                subrProgram = subrSet[subrNumber].program
+                program[:0] = subrProgram
+            # Now pop the actual width
+            assert len(program) >= 1, program
+            program.pop(0)
+
+        if program and program[-1] == "endchar":
+            program.pop()
+
+    if removeUnusedSubrs:
+        cff.remove_unused_subroutines()
+
+    # Upconvert TopDict
+
+    cff.major = 2
+    cff2GetGlyphOrder = cff.otFont.getGlyphOrder
+    topDictData = TopDictIndex(None, cff2GetGlyphOrder)
+    for item in cff.topDictIndex:
+        # Iterate over, such that all are decompiled
+        topDictData.append(item)
+    cff.topDictIndex = topDictData
+    topDict = topDictData[0]
+    if hasattr(topDict, "Private"):
+        privateDict = topDict.Private
+    else:
+        privateDict = None
+    opOrder = buildOrder(topDictOperators2)
+    topDict.order = opOrder
+    topDict.cff2GetGlyphOrder = cff2GetGlyphOrder
+
+    if not hasattr(topDict, "FDArray"):
+        fdArray = topDict.FDArray = FDArrayIndex()
+        fdArray.strings = None
+        fdArray.GlobalSubrs = topDict.GlobalSubrs
+        topDict.GlobalSubrs.fdArray = fdArray
+        charStrings = topDict.CharStrings
+        if charStrings.charStringsAreIndexed:
+            charStrings.charStringsIndex.fdArray = fdArray
+        else:
+            charStrings.fdArray = fdArray
+        fontDict = FontDict()
+        fontDict.setCFF2(True)
+        fdArray.append(fontDict)
+        fontDict.Private = privateDict
+        privateOpOrder = buildOrder(privateDictOperators2)
+        if privateDict is not None:
+            for entry in privateDictOperators:
+                key = entry[1]
+                if key not in privateOpOrder:
+                    if key in privateDict.rawDict:
+                        # print "Removing private dict", key
+                        del privateDict.rawDict[key]
+                    if hasattr(privateDict, key):
+                        delattr(privateDict, key)
+                        # print "Removing privateDict attr", key
+    else:
+        # clean up the PrivateDicts in the fdArray
+        fdArray = topDict.FDArray
+        privateOpOrder = buildOrder(privateDictOperators2)
+        for fontDict in fdArray:
+            fontDict.setCFF2(True)
+            for key in list(fontDict.rawDict.keys()):
+                if key not in fontDict.order:
+                    del fontDict.rawDict[key]
+                    if hasattr(fontDict, key):
+                        delattr(fontDict, key)
+
+            privateDict = fontDict.Private
+            for entry in privateDictOperators:
+                key = entry[1]
+                if key not in privateOpOrder:
+                    if key in list(privateDict.rawDict.keys()):
+                        # print "Removing private dict", key
+                        del privateDict.rawDict[key]
+                    if hasattr(privateDict, key):
+                        delattr(privateDict, key)
+                        # print "Removing privateDict attr", key
+
+    # Now delete up the deprecated topDict operators from CFF 1.0
+    for entry in topDictOperators:
+        key = entry[1]
+        # We seem to need to keep the charset operator for now,
+        # or we fail to compile with some fonts, like AdditionFont.otf.
+        # I don't know which kind of CFF font those are. But keeping
+        # charset seems to work. It will be removed when we save and
+        # read the font again.
+        #
+        # AdditionFont.otf has <Encoding name="StandardEncoding"/>.
+        if key == "charset":
+            continue
+        if key not in opOrder:
+            if key in topDict.rawDict:
+                del topDict.rawDict[key]
+            if hasattr(topDict, key):
+                delattr(topDict, key)
+
+    # TODO(behdad): What does the following comment even mean? Both CFF and CFF2
+    # use the same T2Charstring class. I *think* what it means is that the CharStrings
+    # were loaded for CFF1, and we need to reload them for CFF2 to set varstore, etc
+    # on them. At least that's what I understand. It's probably safe to remove this
+    # and just set vstore where needed.
+    #
+    # See comment above about charset as well.
+
+    # At this point, the Subrs and Charstrings are all still T2Charstring class
+    # easiest to fix this by compiling, then decompiling again
+    file = BytesIO()
+    cff.compile(file, otFont, isCFF2=True)
+    file.seek(0)
+    cff.decompile(file, otFont, isCFF2=True)
+
+
+def convertCFFToCFF2(font):
+    cff = font["CFF "].cff
+    del font["CFF "]
+    _convertCFFToCFF2(cff, font)
+    table = font["CFF2"] = newTable("CFF2")
+    table.cff = cff
+
+
+def main(args=None):
+    """Convert CFF OTF font to CFF2 OTF font"""
+    if args is None:
+        import sys
+
+        args = sys.argv[1:]
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools cffLib.CFFToCFF2",
+        description="Upgrade a CFF font to CFF2.",
+    )
+    parser.add_argument(
+        "input", metavar="INPUT.ttf", help="Input OTF file with CFF table."
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        metavar="OUTPUT.ttf",
+        default=None,
+        help="Output instance OTF file (default: INPUT-CFF2.ttf).",
+    )
+    parser.add_argument(
+        "--no-recalc-timestamp",
+        dest="recalc_timestamp",
+        action="store_false",
+        help="Don't set the output font's timestamp to the current time.",
+    )
+    loggingGroup = parser.add_mutually_exclusive_group(required=False)
+    loggingGroup.add_argument(
+        "-v", "--verbose", action="store_true", help="Run more verbosely."
+    )
+    loggingGroup.add_argument(
+        "-q", "--quiet", action="store_true", help="Turn verbosity off."
+    )
+    options = parser.parse_args(args)
+
+    from fontTools import configLogger
+
+    configLogger(
+        level=("DEBUG" if options.verbose else "ERROR" if options.quiet else "INFO")
+    )
+
+    import os
+
+    infile = options.input
+    if not os.path.isfile(infile):
+        parser.error("No such file '{}'".format(infile))
+
+    outfile = (
+        makeOutputFileName(infile, overWrite=True, suffix="-CFF2")
+        if not options.output
+        else options.output
+    )
+
+    font = TTFont(infile, recalcTimestamp=options.recalc_timestamp, recalcBBoxes=False)
+
+    convertCFFToCFF2(font)
+
+    log.info(
+        "Saving %s",
+        outfile,
+    )
+    font.save(outfile)
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main(sys.argv[1:]))