Update contrib/python/contourpy to 1.2.0

contrib/python/contourpy/.dist-info/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: contourpy
-Version: 1.1.1
+Version: 1.2.0
 Summary: Python library for calculating contours of 2D quadrilateral grids
 Author-Email: Ian Thomas <ianthomas23@gmail.com>
 License: BSD 3-Clause License
@@ -38,7 +38,6 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: C++
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -50,9 +49,8 @@ Project-URL: Homepage, https://github.com/contourpy/contourpy
 Project-URL: Changelog, https://contourpy.readthedocs.io/en/latest/changelog.html
 Project-URL: Documentation, https://contourpy.readthedocs.io
 Project-URL: Repository, https://github.com/contourpy/contourpy
-Requires-Python: >=3.8
-Requires-Dist: numpy<2.0,>=1.16; python_version <= "3.11"
-Requires-Dist: numpy<2.0,>=1.26.0rc1; python_version >= "3.12"
+Requires-Python: >=3.9
+Requires-Dist: numpy<2.0,>=1.20
 Requires-Dist: furo; extra == "docs"
 Requires-Dist: sphinx>=7.2; extra == "docs"
 Requires-Dist: sphinx-copybutton; extra == "docs"
@@ -60,13 +58,14 @@ Requires-Dist: bokeh; extra == "bokeh"
 Requires-Dist: selenium; extra == "bokeh"
 Requires-Dist: contourpy[bokeh,docs]; extra == "mypy"
 Requires-Dist: docutils-stubs; extra == "mypy"
-Requires-Dist: mypy==1.4.1; extra == "mypy"
+Requires-Dist: mypy==1.6.1; extra == "mypy"
 Requires-Dist: types-Pillow; extra == "mypy"
 Requires-Dist: contourpy[test-no-images]; extra == "test"
 Requires-Dist: matplotlib; extra == "test"
 Requires-Dist: Pillow; extra == "test"
 Requires-Dist: pytest; extra == "test-no-images"
 Requires-Dist: pytest-cov; extra == "test-no-images"
+Requires-Dist: pytest-xdist; extra == "test-no-images"
 Requires-Dist: wurlitzer; extra == "test-no-images"
 Provides-Extra: docs
 Provides-Extra: bokeh

contrib/python/contourpy/contourpy/__init__.py

@@ -10,6 +10,8 @@ from contourpy._contourpy import (
 )
 from contourpy._version import __version__
 from contourpy.chunk import calc_chunk_sizes
+from contourpy.convert import convert_filled, convert_lines
+from contourpy.dechunk import dechunk_filled, dechunk_lines
 from contourpy.enum_util import as_fill_type, as_line_type, as_z_interp
 
 if TYPE_CHECKING:
@@ -22,6 +24,10 @@ if TYPE_CHECKING:
 __all__ = [
     "__version__",
     "contour_generator",
+    "convert_filled",
+    "convert_lines",
+    "dechunk_filled",
+    "dechunk_lines",
     "max_threads",
     "FillType",
     "LineType",
@@ -74,10 +80,10 @@ def contour_generator(
     z_interp: ZInterp | str | None = ZInterp.Linear,
     thread_count: int = 0,
 ) -> ContourGenerator:
-    """Create and return a contour generator object.
+    """Create and return a :class:`~contourpy._contourpy.ContourGenerator` object.
 
-    The class and properties of the contour generator are determined by the function arguments,
-    with sensible defaults.
+    The class and properties of the returned :class:`~contourpy._contourpy.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.
@@ -96,12 +102,14 @@ def contour_generator(
             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, optional): The format of contour line data returned from calls to
-            :meth:`~contourpy.ContourGenerator.lines`. If not specified, uses the default provided
-            by the algorithm ``name``.
-        fill_type (FillType, optional): The format of filled contour data returned from calls to
-            :meth:`~contourpy.ContourGenerator.filled`. 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:`~contourpy.ContourGenerator.lines`, specified either as a
+            :class:`~contourpy.LineType` or its string equivalent such as ``"SeparateCode"``.
+            If not specified, uses the default provided by the algorithm ``name``.
+        fill_type (FillType or str, optional): The format of filled contour data returned from calls
+            to :meth:`~contourpy.ContourGenerator.filled`, specified either as a
+            :class:`~contourpy.FillType` or its string equivalent such as ``"OuterOffset"``.
+            If not specified, uses the default provided by the algorithm ``name``.
         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
@@ -113,9 +121,10 @@ def contour_generator(
             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): 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,
-            default ``ZInterp.Linear``.
+        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.

contrib/python/contourpy/contourpy/_version.py

@@ -1 +1 @@
-__version__ = "1.1.1"
+__version__ = "1.2.0"

contrib/python/contourpy/contourpy/array.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+from itertools import chain
+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)]))  # type: ignore[arg-type]
+        return [points[s+1:e] for s, e in zip(nan_offsets[:-1], nan_offsets[1:])]

contrib/python/contourpy/contourpy/convert.py

@@ -0,0 +1,555 @@
+from __future__ import annotations
+
+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
+                                         zip(outer_offsets[:-1], outer_offsets[1:])]
+                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:
+    """Return the specified filled contours converted to a different :class:`~contourpy.FillType`.
+
+    Args:
+        filled (sequence of arrays): Filled contour polygons to convert.
+        fill_type_from (FillType or str): :class:`~contourpy.FillType` to convert from as enum or
+            string equivalent.
+        fill_type_to (FillType or str): :class:`~contourpy.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:
+    """Return the specified contour lines converted to a different :class:`~contourpy.LineType`.
+
+    Args:
+        lines (sequence of arrays): Contour lines to convert.
+        line_type_from (LineType or str): :class:`~contourpy.LineType` to convert from as enum or
+            string equivalent.
+        line_type_to (LineType or str): :class:`~contourpy.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}")

contrib/python/contourpy/contourpy/dechunk.py

@@ -0,0 +1,142 @@
+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 all 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 as returned by
+            :func:`~contourpy.ContourGenerator.filled`.
+        fill_type (FillType or str): Type of ``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 all 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 as returned by
+            :func:`~contourpy.ContourGenerator.lines`.
+        line_type (LineType or str): Type of ``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}")

contrib/python/contourpy/contourpy/enum_util.py

@@ -13,7 +13,10 @@ def as_fill_type(fill_type: FillType | str) -> FillType:
         FillType: Converted value.
     """
     if isinstance(fill_type, str):
-        return FillType.__members__[fill_type]
+        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
 
@@ -28,7 +31,10 @@ def as_line_type(line_type: LineType | str) -> LineType:
         LineType: Converted value.
     """
     if isinstance(line_type, str):
-        return LineType.__members__[line_type]
+        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
 
@@ -43,6 +49,9 @@ def as_z_interp(z_interp: ZInterp | str) -> ZInterp:
         ZInterp: Converted value.
     """
     if isinstance(z_interp, str):
-        return ZInterp.__members__[z_interp]
+        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

contrib/python/contourpy/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}")

contrib/python/contourpy/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

contrib/python/contourpy/contourpy/util/_build_config.py

@@ -9,6 +9,8 @@ def build_config() -> dict[str, str]:
 
     All dictionary keys and values are strings, for example ``False`` is
     returned as ``"False"``.
+
+        .. versionadded:: 1.1.0
     """
     return dict(
         # Python settings