Add shapely stubs (#12033)

stubs/shapely/@tests/stubtest_allowlist.txt

@@ -0,0 +1,4 @@
+shapely\.geometry\.conftest
+shapely\.tests.*
+
+shapely\._typing  # stubs only module

stubs/shapely/METADATA.toml

@@ -0,0 +1,4 @@
+version = "2.0.*"
+# Requires a version of numpy with a `py.typed` file
+requires = ["numpy>=1.20"]
+upstream_repository = "https://github.com/shapely/shapely"

stubs/shapely/shapely/__init__.pyi

@@ -0,0 +1,34 @@
+from typing import Final
+
+from . import affinity as affinity
+from ._geometry import *
+from .constructive import *
+from .coordinates import *
+from .creation import *
+from .errors import setup_signal_checks as setup_signal_checks
+from .geometry import (
+    GeometryCollection as GeometryCollection,
+    LinearRing as LinearRing,
+    LineString as LineString,
+    MultiLineString as MultiLineString,
+    MultiPoint as MultiPoint,
+    MultiPolygon as MultiPolygon,
+    Point as Point,
+    Polygon as Polygon,
+)
+from .io import *
+from .lib import (
+    Geometry as Geometry,
+    GEOSException as GEOSException,
+    geos_capi_version as geos_capi_version,
+    geos_capi_version_string as geos_capi_version_string,
+    geos_version as geos_version,
+    geos_version_string as geos_version_string,
+)
+from .linear import *
+from .measurement import *
+from .predicates import *
+from .set_operations import *
+from .strtree import *
+
+__version__: Final[str]

stubs/shapely/shapely/_enum.pyi

@@ -0,0 +1,5 @@
+from enum import IntEnum
+
+class ParamEnum(IntEnum):
+    @classmethod
+    def get_value(cls, item: str) -> int: ...

stubs/shapely/shapely/_geometry.pyi

@@ -0,0 +1,184 @@
+from enum import IntEnum
+from typing import Any, Literal, SupportsIndex, overload
+from typing_extensions import TypeAlias
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ._enum import ParamEnum
+from ._typing import ArrayLike, ArrayLikeSeq, GeoArray, OptGeoArrayLike, OptGeoArrayLikeSeq, OptGeoT
+from .geometry import LinearRing, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon
+from .geometry.base import BaseGeometry, BaseMultipartGeometry
+from .lib import Geometry
+
+__all__ = [
+    "GeometryType",
+    "get_type_id",
+    "get_dimensions",
+    "get_coordinate_dimension",
+    "get_num_coordinates",
+    "get_srid",
+    "set_srid",
+    "get_x",
+    "get_y",
+    "get_z",
+    "get_exterior_ring",
+    "get_num_points",
+    "get_num_interior_rings",
+    "get_num_geometries",
+    "get_point",
+    "get_interior_ring",
+    "get_geometry",
+    "get_parts",
+    "get_rings",
+    "get_precision",
+    "set_precision",
+    "force_2d",
+    "force_3d",
+]
+
+_PrecisionMode: TypeAlias = Literal["valid_output", "pointwise", "keep_collapsed", 0, 1, 2]
+
+class GeometryType(IntEnum):
+    MISSING = -1
+    POINT = 0
+    LINESTRING = 1
+    LINEARRING = 2
+    POLYGON = 3
+    MULTIPOINT = 4
+    MULTILINESTRING = 5
+    MULTIPOLYGON = 6
+    GEOMETRYCOLLECTION = 7
+
+@overload
+def get_type_id(geometry: Geometry | None, **kwargs) -> int: ...
+@overload
+def get_type_id(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.int64]: ...
+@overload
+def get_dimensions(geometry: Geometry | None, **kwargs) -> int: ...
+@overload
+def get_dimensions(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.int64]: ...
+@overload
+def get_coordinate_dimension(geometry: Geometry | None, **kwargs) -> int: ...
+@overload
+def get_coordinate_dimension(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.int64]: ...
+@overload
+def get_num_coordinates(geometry: Geometry | None, **kwargs) -> int: ...
+@overload
+def get_num_coordinates(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.int64]: ...
+@overload
+def get_srid(geometry: Geometry | None, **kwargs) -> int: ...
+@overload
+def get_srid(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.int64]: ...
+@overload
+def set_srid(geometry: OptGeoT, srid: SupportsIndex, **kwargs) -> OptGeoT: ...
+@overload
+def set_srid(geometry: OptGeoArrayLikeSeq, srid: ArrayLike[SupportsIndex], **kwargs) -> GeoArray: ...
+@overload
+def set_srid(geometry: OptGeoArrayLike, srid: ArrayLikeSeq[SupportsIndex], **kwargs) -> GeoArray: ...
+@overload
+def get_x(point: Geometry | None, **kwargs) -> float: ...
+@overload
+def get_x(point: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.float64]: ...
+@overload
+def get_y(point: Geometry | None, **kwargs) -> float: ...
+@overload
+def get_y(point: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.float64]: ...
+@overload
+def get_z(point: Geometry | None, **kwargs) -> float: ...
+@overload
+def get_z(point: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.float64]: ...
+@overload
+def get_point(geometry: LineString, index: SupportsIndex, **kwargs) -> Point | Any: ...
+@overload
+def get_point(geometry: Point | Polygon | BaseMultipartGeometry | None, index: SupportsIndex, **kwargs) -> None: ...
+@overload
+def get_point(geometry: Geometry, index: SupportsIndex, **kwargs) -> Point | None: ...
+@overload
+def get_point(geometry: OptGeoArrayLikeSeq, index: ArrayLike[SupportsIndex], **kwargs) -> GeoArray: ...
+@overload
+def get_point(geometry: OptGeoArrayLike, index: ArrayLikeSeq[SupportsIndex], **kwargs) -> GeoArray: ...
+@overload
+def get_num_points(geometry: Geometry | None, **kwargs) -> int: ...
+@overload
+def get_num_points(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.int64]: ...
+@overload
+def get_exterior_ring(geometry: Polygon, **kwargs) -> LinearRing: ...
+@overload
+def get_exterior_ring(geometry: Point | LineString | BaseMultipartGeometry | None, **kwargs) -> None: ...
+@overload
+def get_exterior_ring(geometry: Geometry, **kwargs) -> LinearRing | None: ...
+@overload
+def get_exterior_ring(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def get_interior_ring(geometry: Polygon, index: SupportsIndex, **kwargs) -> LinearRing | Any: ...
+@overload
+def get_interior_ring(geometry: Point | LineString | BaseMultipartGeometry | None, index: SupportsIndex, **kwargs) -> None: ...
+@overload
+def get_interior_ring(geometry: Geometry, index: SupportsIndex, **kwargs) -> LinearRing | None: ...
+@overload
+def get_interior_ring(geometry: OptGeoArrayLikeSeq, index: ArrayLike[SupportsIndex], **kwargs) -> GeoArray: ...
+@overload
+def get_interior_ring(geometry: OptGeoArrayLike, index: ArrayLikeSeq[SupportsIndex], **kwargs) -> GeoArray: ...
+@overload
+def get_num_interior_rings(geometry: Geometry | None, **kwargs) -> int: ...
+@overload
+def get_num_interior_rings(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.int64]: ...
+@overload
+def get_geometry(geometry: MultiPoint, index: SupportsIndex, **kwargs) -> Point | Any: ...
+@overload
+def get_geometry(geometry: MultiLineString, index: SupportsIndex, **kwargs) -> LineString | Any: ...
+@overload
+def get_geometry(geometry: MultiPolygon, index: SupportsIndex, **kwargs) -> Polygon | Any: ...
+@overload
+def get_geometry(geometry: BaseMultipartGeometry, index: SupportsIndex, **kwargs) -> BaseGeometry | Any: ...
+@overload
+def get_geometry(geometry: None, index: SupportsIndex, **kwargs) -> None: ...
+@overload
+def get_geometry(geometry: Geometry | None, index: SupportsIndex, **kwargs) -> BaseGeometry | None: ...
+@overload
+def get_geometry(geometry: OptGeoArrayLikeSeq, index: ArrayLike[SupportsIndex], **kwargs) -> GeoArray: ...
+@overload
+def get_geometry(geometry: OptGeoArrayLike, index: ArrayLikeSeq[SupportsIndex], **kwargs) -> GeoArray: ...
+@overload
+def get_parts(geometry: OptGeoArrayLike, return_index: Literal[False] = False) -> GeoArray: ...
+@overload
+def get_parts(geometry: OptGeoArrayLike, return_index: Literal[True]) -> tuple[GeoArray, NDArray[np.int64]]: ...
+@overload
+def get_parts(geometry: OptGeoArrayLike, return_index: bool) -> GeoArray | tuple[GeoArray, NDArray[np.int64]]: ...
+@overload
+def get_rings(geometry: OptGeoArrayLike, return_index: Literal[False] = False) -> GeoArray: ...
+@overload
+def get_rings(geometry: OptGeoArrayLike, return_index: Literal[True]) -> tuple[GeoArray, NDArray[np.int64]]: ...
+@overload
+def get_rings(geometry: OptGeoArrayLike, return_index: bool) -> GeoArray | tuple[GeoArray, NDArray[np.int64]]: ...
+@overload
+def get_num_geometries(geometry: Geometry | None, **kwargs) -> int: ...
+@overload
+def get_num_geometries(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.int64]: ...
+@overload
+def get_precision(geometry: Geometry | None, **kwargs) -> float: ...
+@overload
+def get_precision(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.float64]: ...
+
+class SetPrecisionMode(ParamEnum):
+    valid_output: int
+    pointwise: int
+    keep_collapsed: int
+
+@overload
+def set_precision(geometry: OptGeoT, grid_size: float, mode: _PrecisionMode = "valid_output", **kwargs) -> OptGeoT: ...
+@overload
+def set_precision(
+    geometry: OptGeoArrayLikeSeq, grid_size: float, mode: _PrecisionMode = "valid_output", **kwargs
+) -> GeoArray: ...
+@overload
+def force_2d(geometry: OptGeoT, **kwargs) -> OptGeoT: ...
+@overload
+def force_2d(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def force_3d(geometry: OptGeoT, z: float = 0.0, **kwargs) -> OptGeoT: ...
+@overload
+def force_3d(geometry: OptGeoArrayLikeSeq, z: ArrayLike[float] = 0.0, **kwargs) -> GeoArray: ...
+@overload
+def force_3d(geometry: OptGeoArrayLike, z: ArrayLikeSeq[float], **kwargs) -> GeoArray: ...

stubs/shapely/shapely/_ragged_array.pyi

@@ -0,0 +1,12 @@
+import numpy as np
+from numpy.typing import NDArray
+
+from ._geometry import GeometryType
+from ._typing import ArrayLike, ArrayLikeSeq, GeoArray, OptGeoArrayLikeSeq
+
+def to_ragged_array(
+    geometries: OptGeoArrayLikeSeq, include_z: bool | None = None
+) -> tuple[GeometryType, NDArray[np.float64], tuple[NDArray[np.int64], ...]]: ...
+def from_ragged_array(
+    geometry_type: GeometryType, coords: ArrayLike[float], offsets: ArrayLikeSeq[int] | None = None
+) -> GeoArray: ...

stubs/shapely/shapely/_typing.pyi

@@ -0,0 +1,51 @@
+import sys
+from collections.abc import Sequence
+from typing import Any, Protocol, TypeVar, type_check_only
+from typing_extensions import TypeAlias
+
+import numpy as np
+from numpy.typing import NDArray
+
+from .lib import Geometry
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+
+_T = TypeVar("_T")
+_DType = TypeVar("_DType", bound=np.dtype[Any])
+_DType_co = TypeVar("_DType_co", covariant=True, bound=np.dtype[Any])
+
+GeoT = TypeVar("GeoT", bound=Geometry)  # noqa: Y001
+OptGeoT = TypeVar("OptGeoT", bound=Geometry | None)  # noqa: Y001
+
+@type_check_only
+class SupportsArray(Protocol[_DType_co]):
+    def __array__(self) -> np.ndarray[Any, _DType_co]: ...
+
+# TODO revisit when mypy is happy with generic recursive type alias
+# NestedSequence: TypeAlias = Sequence[_T] | Sequence[NestedSequence[_T]]
+NestedSequence: TypeAlias = Sequence[_T] | Sequence[Sequence[_T]] | Sequence[Sequence[Sequence[_T]]]
+DualArrayLike: TypeAlias = SupportsArray[_DType] | NestedSequence[SupportsArray[_DType]] | NestedSequence[_T]
+
+# array-like sequences: objects accepted by np.array that produce at least 1-D arrays
+if sys.version_info >= (3, 12):
+    ArrayLikeSeq: TypeAlias = Buffer | DualArrayLike[np.dtype[Any], _T]
+else:
+    ArrayLikeSeq: TypeAlias = DualArrayLike[np.dtype[Any], _T]
+GeoArrayLikeSeq: TypeAlias = ArrayLikeSeq[Geometry]
+OptGeoArrayLikeSeq: TypeAlias = ArrayLikeSeq[Geometry | None]
+
+# array-like: objects accepted by np.array that may also produce 0-D array
+ArrayLike: TypeAlias = _T | ArrayLikeSeq[_T]
+GeoArrayLike: TypeAlias = ArrayLike[Geometry]
+OptGeoArrayLike: TypeAlias = ArrayLike[Geometry | None]
+
+# There is no way to pronounce "array of BaseGeometry" currently because of the restriction on
+# NDArray type variable to np.dtype and because np.object_ is not generic.
+# Note the use of `BaseGeometry` instead of `Geometry` as the alias is used in return types.
+GeoArray: TypeAlias = NDArray[np.object_]
+
+@type_check_only
+class SupportsGeoInterface(Protocol):
+    @property
+    def __geo_interface__(self) -> dict[str, Any]: ...

stubs/shapely/shapely/_version.pyi

@@ -0,0 +1,6 @@
+from typing import TypedDict
+
+version_json: str
+_Versions = TypedDict("_Versions", {"date": str, "dirty": bool, "error": None, "full-revisionid": str, "version": str})
+
+def get_versions() -> _Versions: ...

stubs/shapely/shapely/affinity.pyi

@@ -0,0 +1,23 @@
+from collections.abc import Collection
+from typing import Literal, overload
+from typing_extensions import TypeAlias
+
+from ._typing import GeoT
+from .geometry import Point
+from .lib import Geometry
+
+__all__ = ["affine_transform", "rotate", "scale", "skew", "translate"]
+
+_Origin: TypeAlias = Literal["center", "centroid"] | Point | tuple[float, float] | tuple[float, float, float]
+
+def affine_transform(geom: GeoT, matrix: Collection[float]) -> GeoT: ...
+@overload
+def interpret_origin(geom: Geometry, origin: _Origin, ndim: Literal[2]) -> tuple[float, float]: ...
+@overload
+def interpret_origin(geom: Geometry, origin: _Origin, ndim: Literal[3]) -> tuple[float, float, float]: ...
+@overload
+def interpret_origin(geom: Geometry, origin: _Origin, ndim: int) -> tuple[float, float] | tuple[float, float, float]: ...
+def rotate(geom: GeoT, angle: float, origin: _Origin = "center", use_radians: bool = False) -> GeoT: ...
+def scale(geom: GeoT, xfact: float = 1.0, yfact: float = 1.0, zfact: float = 1.0, origin: _Origin = "center") -> GeoT: ...
+def skew(geom: GeoT, xs: float = 0.0, ys: float = 0.0, origin: _Origin = "center", use_radians: bool = False) -> GeoT: ...
+def translate(geom: GeoT, xoff: float = 0.0, yoff: float = 0.0, zoff: float = 0.0) -> GeoT: ...

stubs/shapely/shapely/algorithms/cga.pyi

@@ -0,0 +1,6 @@
+from collections.abc import Callable
+
+from ..geometry import LinearRing
+
+def signed_area(ring: LinearRing) -> float: ...
+def is_ccw_impl(name: None = None) -> Callable[[LinearRing], bool]: ...

stubs/shapely/shapely/algorithms/polylabel.pyi

@@ -0,0 +1,19 @@
+from ..errors import TopologicalError as TopologicalError
+from ..geometry import Point, Polygon
+
+class Cell:
+    x: float
+    y: float
+    h: float
+    centroid: Point
+    distance: float
+    max_distance: float
+    def __init__(self, x: float, y: float, h: float, polygon: Polygon) -> None: ...
+    def __lt__(self, other: Cell) -> bool: ...
+    def __le__(self, other: Cell) -> bool: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __gt__(self, other: Cell) -> bool: ...
+    def __ge__(self, other: Cell) -> bool: ...
+
+def polylabel(polygon: Polygon, tolerance: float = 1.0) -> Point: ...

stubs/shapely/shapely/constructive.pyi

@@ -0,0 +1,430 @@
+from collections.abc import Sequence
+from typing import Any, Literal, SupportsIndex, overload
+
+from ._enum import ParamEnum
+from ._typing import ArrayLike, ArrayLikeSeq, GeoArray, OptGeoArrayLike, OptGeoArrayLikeSeq, OptGeoT
+from .geometry import GeometryCollection, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon
+from .geometry.base import BaseGeometry, BaseMultipartGeometry
+from .lib import Geometry
+
+__all__ = [
+    "BufferCapStyle",
+    "BufferJoinStyle",
+    "boundary",
+    "buffer",
+    "offset_curve",
+    "centroid",
+    "clip_by_rect",
+    "concave_hull",
+    "convex_hull",
+    "delaunay_triangles",
+    "segmentize",
+    "envelope",
+    "extract_unique_points",
+    "build_area",
+    "make_valid",
+    "normalize",
+    "node",
+    "point_on_surface",
+    "polygonize",
+    "polygonize_full",
+    "remove_repeated_points",
+    "reverse",
+    "simplify",
+    "snap",
+    "voronoi_polygons",
+    "oriented_envelope",
+    "minimum_rotated_rectangle",
+    "minimum_bounding_circle",
+]
+
+class BufferCapStyle(ParamEnum):
+    round: int
+    flat: int
+    square: int
+
+class BufferJoinStyle(ParamEnum):
+    round: int
+    mitre: int
+    bevel: int
+
+@overload
+def boundary(geometry: Point | MultiPoint, **kwargs) -> GeometryCollection: ...
+@overload
+def boundary(geometry: LineString | MultiLineString, **kwargs) -> MultiPoint: ...
+@overload
+def boundary(geometry: Polygon | MultiPolygon, **kwargs) -> MultiLineString: ...
+@overload
+def boundary(geometry: GeometryCollection | None, **kwargs) -> None: ...
+@overload
+def boundary(geometry: Geometry, **kwargs) -> BaseMultipartGeometry | Any: ...
+@overload
+def boundary(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def buffer(
+    geometry: Geometry,
+    distance: float,
+    quad_segs: int = 8,
+    cap_style: BufferJoinStyle | Literal["round", "square", "flat"] = "round",
+    join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+    mitre_limit: float = 5.0,
+    single_sided: bool = False,
+    **kwargs,
+) -> Polygon: ...
+@overload
+def buffer(
+    geometry: None,
+    distance: float,
+    quad_segs: int = 8,
+    cap_style: BufferJoinStyle | Literal["round", "square", "flat"] = "round",
+    join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+    mitre_limit: float = 5.0,
+    single_sided: bool = False,
+    **kwargs,
+) -> None: ...
+@overload
+def buffer(
+    geometry: Geometry | None,
+    distance: float,
+    quad_segs: int = 8,
+    cap_style: BufferJoinStyle | Literal["round", "square", "flat"] = "round",
+    join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+    mitre_limit: float = 5.0,
+    single_sided: bool = False,
+    **kwargs,
+) -> Polygon | None: ...
+@overload
+def buffer(
+    geometry: OptGeoArrayLike,
+    distance: ArrayLikeSeq[float],
+    quad_segs: int = 8,
+    cap_style: BufferJoinStyle | Literal["round", "square", "flat"] = "round",
+    join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+    mitre_limit: float = 5.0,
+    single_sided: bool = False,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def buffer(
+    geometry: OptGeoArrayLikeSeq,
+    distance: ArrayLike[float],
+    quad_segs: int = 8,
+    cap_style: BufferJoinStyle | Literal["round", "square", "flat"] = "round",
+    join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+    mitre_limit: float = 5.0,
+    single_sided: bool = False,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def offset_curve(
+    geometry: Geometry,
+    distance: float,
+    quad_segs: SupportsIndex = 8,
+    join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+    mitre_limit: float = 5.0,
+    **kwargs,
+) -> LineString | MultiLineString: ...
+@overload
+def offset_curve(
+    geometry: None,
+    distance: float,
+    quad_segs: SupportsIndex = 8,
+    join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+    mitre_limit: float = 5.0,
+    **kwargs,
+) -> None: ...
+@overload
+def offset_curve(
+    geometry: Geometry | None,
+    distance: float,
+    quad_segs: SupportsIndex = 8,
+    join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+    mitre_limit: float = 5.0,
+    **kwargs,
+) -> LineString | MultiLineString | None: ...
+@overload
+def offset_curve(
+    geometry: OptGeoArrayLike,
+    distance: ArrayLikeSeq[float],
+    quad_segs: SupportsIndex = 8,
+    join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+    mitre_limit: float = 5.0,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def offset_curve(
+    geometry: OptGeoArrayLikeSeq,
+    distance: ArrayLike[float],
+    quad_segs: SupportsIndex = 8,
+    join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+    mitre_limit: float = 5.0,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def centroid(geometry: Geometry, **kwargs) -> Point: ...
+@overload
+def centroid(geometry: None, **kwargs) -> None: ...
+@overload
+def centroid(geometry: Geometry | None, **kwargs) -> Point | None: ...
+@overload
+def centroid(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def clip_by_rect(geometry: Geometry, xmin: float, ymin: float, xmax: float, ymax: float, **kwargs) -> BaseGeometry: ...
+@overload
+def clip_by_rect(geometry: None, xmin: float, ymin: float, xmax: float, ymax: float, **kwargs) -> None: ...
+@overload
+def clip_by_rect(
+    geometry: Geometry | None, xmin: float, ymin: float, xmax: float, ymax: float, **kwargs
+) -> BaseGeometry | None: ...
+@overload
+def clip_by_rect(geometry: OptGeoArrayLikeSeq, xmin: float, ymin: float, xmax: float, ymax: float, **kwargs) -> GeoArray: ...
+@overload
+def concave_hull(geometry: Geometry, ratio: float = 0.0, allow_holes: bool = False, **kwargs) -> BaseGeometry: ...
+@overload
+def concave_hull(geometry: None, ratio: float = 0.0, allow_holes: bool = False, **kwargs) -> None: ...
+@overload
+def concave_hull(geometry: Geometry | None, ratio: float = 0.0, allow_holes: bool = False, **kwargs) -> BaseGeometry | None: ...
+@overload
+def concave_hull(geometry: OptGeoArrayLikeSeq, ratio: float = 0.0, allow_holes: bool = False, **kwargs) -> GeoArray: ...
+@overload
+def convex_hull(geometry: Geometry, **kwargs) -> BaseGeometry: ...
+@overload
+def convex_hull(geometry: None, **kwargs) -> None: ...
+@overload
+def convex_hull(geometry: Geometry | None, **kwargs) -> BaseGeometry | None: ...
+@overload
+def convex_hull(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def delaunay_triangles(
+    geometry: Geometry, tolerance: float = 0.0, only_edges: Literal[False] = False, **kwargs
+) -> GeometryCollection: ...
+@overload
+def delaunay_triangles(geometry: Geometry, tolerance: float, only_edges: Literal[True], **kwargs) -> MultiLineString: ...
+@overload
+def delaunay_triangles(geometry: Geometry, tolerance: float = 0.0, *, only_edges: Literal[True], **kwargs) -> MultiLineString: ...
+@overload
+def delaunay_triangles(
+    geometry: Geometry, tolerance: float = 0.0, only_edges: bool = False, **kwargs
+) -> GeometryCollection | MultiLineString: ...
+@overload
+def delaunay_triangles(geometry: None, tolerance: float = 0.0, only_edges: bool = False, **kwargs) -> None: ...
+@overload
+def delaunay_triangles(
+    geometry: Geometry | None, tolerance: float = 0.0, only_edges: bool = False, **kwargs
+) -> GeometryCollection | MultiLineString | None: ...
+@overload
+def delaunay_triangles(
+    geometry: OptGeoArrayLike, tolerance: ArrayLike[float], only_edges: ArrayLikeSeq[bool], **kwargs
+) -> GeoArray: ...
+@overload
+def delaunay_triangles(
+    geometry: OptGeoArrayLike, tolerance: ArrayLike[float] = 0.0, *, only_edges: ArrayLikeSeq[bool], **kwargs
+) -> GeoArray: ...
+@overload
+def delaunay_triangles(
+    geometry: OptGeoArrayLike, tolerance: ArrayLikeSeq[float], only_edges: ArrayLike[bool] = False, **kwargs
+) -> GeoArray: ...
+@overload
+def delaunay_triangles(
+    geometry: OptGeoArrayLikeSeq, tolerance: ArrayLike[float] = 0.0, only_edges: ArrayLike[bool] = False, **kwargs
+) -> GeoArray: ...
+@overload
+def envelope(geometry: Point, **kwargs) -> Point: ...
+@overload
+def envelope(geometry: Geometry, **kwargs) -> BaseGeometry: ...
+@overload
+def envelope(geometry: None, **kwargs) -> None: ...
+@overload
+def envelope(geometry: Geometry | None, **kwargs) -> BaseGeometry | None: ...
+@overload
+def envelope(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def extract_unique_points(geometry: Geometry, **kwargs) -> MultiPoint: ...
+@overload
+def extract_unique_points(geometry: None, **kwargs) -> None: ...
+@overload
+def extract_unique_points(geometry: Geometry | None, **kwargs) -> MultiPoint | None: ...
+@overload
+def extract_unique_points(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def build_area(geometry: Geometry, **kwargs) -> BaseGeometry: ...
+@overload
+def build_area(geometry: None, **kwargs) -> None: ...
+@overload
+def build_area(geometry: Geometry | None, **kwargs) -> BaseGeometry | None: ...
+@overload
+def build_area(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def make_valid(geometry: Geometry, **kwargs) -> BaseGeometry: ...
+@overload
+def make_valid(geometry: None, **kwargs) -> None: ...
+@overload
+def make_valid(geometry: Geometry | None, **kwargs) -> BaseGeometry | None: ...
+@overload
+def make_valid(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def normalize(geometry: OptGeoT, **kwargs) -> OptGeoT: ...
+@overload
+def normalize(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def point_on_surface(geometry: Geometry, **kwargs) -> Point: ...
+@overload
+def point_on_surface(geometry: None, **kwargs) -> None: ...
+@overload
+def point_on_surface(geometry: Geometry | None, **kwargs) -> Point | None: ...
+@overload
+def point_on_surface(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def node(geometry: Geometry, **kwargs) -> MultiLineString: ...
+@overload
+def node(geometry: None, **kwargs) -> None: ...
+@overload
+def node(geometry: Geometry | None, **kwargs) -> MultiLineString | None: ...
+@overload
+def node(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def polygonize(geometries: Sequence[Geometry | None], **kwargs) -> GeometryCollection: ...
+@overload
+def polygonize(geometries: Sequence[Sequence[Geometry | None]], **kwargs) -> GeoArray: ...
+@overload
+def polygonize(geometries: OptGeoArrayLikeSeq, **kwargs) -> GeometryCollection | GeoArray: ...
+@overload
+def polygonize_full(
+    geometries: Sequence[Geometry | None], **kwargs
+) -> tuple[GeometryCollection, GeometryCollection, GeometryCollection, GeometryCollection]: ...
+@overload
+def polygonize_full(
+    geometries: Sequence[Sequence[Geometry | None]], **kwargs
+) -> tuple[GeoArray, GeoArray, GeoArray, GeoArray]: ...
+@overload
+def polygonize_full(
+    geometries: OptGeoArrayLikeSeq, **kwargs
+) -> (
+    tuple[GeometryCollection, GeometryCollection, GeometryCollection, GeometryCollection]
+    | tuple[GeoArray, GeoArray, GeoArray, GeoArray]
+): ...
+@overload
+def remove_repeated_points(geometry: OptGeoT, tolerance: float = 0.0, **kwargs) -> OptGeoT: ...
+@overload
+def remove_repeated_points(geometry: OptGeoArrayLikeSeq, tolerance: float = 0.0, **kwargs) -> GeoArray: ...
+@overload
+def reverse(geometry: OptGeoT, **kwargs) -> OptGeoT: ...
+@overload
+def reverse(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def segmentize(geometry: OptGeoT, max_segment_length: float, **kwargs) -> OptGeoT: ...
+@overload
+def segmentize(geometry: OptGeoArrayLike, max_segment_length: ArrayLikeSeq[float], **kwargs) -> GeoArray: ...
+@overload
+def segmentize(geometry: OptGeoArrayLikeSeq, max_segment_length: ArrayLike[float], **kwargs) -> GeoArray: ...
+@overload
+def simplify(geometry: OptGeoT, tolerance: float, preserve_topology: bool = True, **kwargs) -> OptGeoT: ...
+@overload
+def simplify(geometry: OptGeoArrayLike, tolerance: ArrayLikeSeq[float], preserve_topology: bool = True, **kwargs) -> GeoArray: ...
+@overload
+def simplify(geometry: OptGeoArrayLikeSeq, tolerance: ArrayLike[float], preserve_topology: bool = True, **kwargs) -> GeoArray: ...
+@overload
+def snap(geometry: OptGeoT, reference: Geometry, tolerance: float, **kwargs) -> OptGeoT: ...
+@overload
+def snap(geometry: Geometry | None, reference: None, tolerance: float, **kwargs) -> None: ...
+@overload
+def snap(geometry: OptGeoArrayLikeSeq, reference: OptGeoArrayLike, tolerance: ArrayLike[float], **kwargs) -> GeoArray: ...
+@overload
+def snap(geometry: OptGeoArrayLike, reference: OptGeoArrayLikeSeq, tolerance: ArrayLike[float], **kwargs) -> GeoArray: ...
+@overload
+def snap(geometry: OptGeoArrayLike, reference: OptGeoArrayLike, tolerance: ArrayLikeSeq[float], **kwargs) -> GeoArray: ...
+@overload
+def voronoi_polygons(
+    geometry: Geometry, tolerance: float = 0.0, extend_to: Geometry | None = None, only_edges: Literal[False] = False, **kwargs
+) -> GeometryCollection[Polygon]: ...
+@overload
+def voronoi_polygons(
+    geometry: Geometry, tolerance: float, extend_to: Geometry | None, only_edges: Literal[True], **kwargs
+) -> LineString | MultiLineString: ...
+@overload
+def voronoi_polygons(
+    geometry: Geometry, tolerance: float = 0.0, extend_to: Geometry | None = None, *, only_edges: Literal[True], **kwargs
+) -> LineString | MultiLineString: ...
+@overload
+def voronoi_polygons(
+    geometry: Geometry, tolerance: float = 0.0, extend_to: Geometry | None = None, only_edges: bool = False, **kwargs
+) -> GeometryCollection[Polygon] | LineString | MultiLineString: ...
+@overload
+def voronoi_polygons(
+    geometry: None, tolerance: float = 0.0, extend_to: Geometry | None = None, only_edges: bool = False, **kwargs
+) -> None: ...
+@overload
+def voronoi_polygons(
+    geometry: Geometry | None, tolerance: float = 0.0, extend_to: Geometry | None = None, only_edges: bool = False, **kwargs
+) -> GeometryCollection[Polygon] | LineString | MultiLineString | None: ...
+@overload
+def voronoi_polygons(
+    geometry: OptGeoArrayLikeSeq,
+    tolerance: ArrayLike[float] = 0.0,
+    extend_to: OptGeoArrayLike = None,
+    only_edges: ArrayLike[bool] = False,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def voronoi_polygons(
+    geometry: OptGeoArrayLike,
+    tolerance: ArrayLikeSeq[float],
+    extend_to: OptGeoArrayLike = None,
+    only_edges: ArrayLike[bool] = False,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def voronoi_polygons(
+    geometry: OptGeoArrayLike,
+    tolerance: ArrayLike[float],
+    extend_to: OptGeoArrayLikeSeq,
+    only_edges: ArrayLike[bool] = False,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def voronoi_polygons(
+    geometry: OptGeoArrayLike,
+    tolerance: ArrayLike[float] = 0.0,
+    *,
+    extend_to: OptGeoArrayLikeSeq,
+    only_edges: ArrayLike[bool] = False,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def voronoi_polygons(
+    geometry: OptGeoArrayLike, tolerance: ArrayLike[float], extend_to: OptGeoArrayLike, only_edges: ArrayLikeSeq[bool], **kwargs
+) -> GeoArray: ...
+@overload
+def voronoi_polygons(
+    geometry: OptGeoArrayLike,
+    tolerance: ArrayLike[float] = 0.0,
+    extend_to: OptGeoArrayLike = None,
+    *,
+    only_edges: ArrayLikeSeq[bool],
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def oriented_envelope(geometry: Point, **kwargs) -> Point: ...
+@overload
+def oriented_envelope(geometry: Geometry, **kwargs) -> BaseGeometry: ...
+@overload
+def oriented_envelope(geometry: None, **kwargs) -> None: ...
+@overload
+def oriented_envelope(geometry: Geometry | None, **kwargs) -> BaseGeometry | None: ...
+@overload
+def oriented_envelope(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+
+minimum_rotated_rectangle = oriented_envelope
+
+@overload
+def minimum_bounding_circle(geometry: Point, **kwargs) -> Point: ...
+@overload
+def minimum_bounding_circle(geometry: LineString | Polygon | BaseMultipartGeometry, **kwargs) -> Polygon: ...
+@overload
+def minimum_bounding_circle(geometry: Geometry, **kwargs) -> Polygon | Point: ...
+@overload
+def minimum_bounding_circle(geometry: None, **kwargs) -> None: ...
+@overload
+def minimum_bounding_circle(geometry: Geometry | None, **kwargs) -> Polygon | Point | None: ...
+@overload
+def minimum_bounding_circle(geometry: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...

stubs/shapely/shapely/coordinates.pyi

@@ -0,0 +1,43 @@
+from collections.abc import Callable
+from typing import Literal, overload
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ._typing import ArrayLikeSeq, GeoArray, GeoT, OptGeoArrayLike, OptGeoArrayLikeSeq, OptGeoT
+
+__all__ = ["transform", "count_coordinates", "get_coordinates", "set_coordinates"]
+
+@overload
+def transform(
+    geometry: OptGeoT, transformation: Callable[[NDArray[np.float64]], NDArray[np.float64]], include_z: bool = False
+) -> OptGeoT: ...
+@overload
+def transform(
+    geometry: OptGeoArrayLikeSeq, transformation: Callable[[NDArray[np.float64]], NDArray[np.float64]], include_z: bool = False
+) -> GeoArray: ...
+def count_coordinates(geometry: OptGeoArrayLike) -> int: ...
+@overload
+def get_coordinates(
+    geometry: OptGeoArrayLike, include_z: bool = False, return_index: Literal[False] = False
+) -> NDArray[np.float64]: ...
+@overload
+def get_coordinates(
+    geometry: OptGeoArrayLike, include_z: bool = False, *, return_index: Literal[True]
+) -> tuple[NDArray[np.float64], NDArray[np.int64]]: ...
+@overload
+def get_coordinates(
+    geometry: OptGeoArrayLike, include_z: bool, return_index: Literal[True]
+) -> tuple[NDArray[np.float64], NDArray[np.int64]]: ...
+@overload
+def get_coordinates(
+    geometry: OptGeoArrayLike, include_z: bool = False, *, return_index: bool
+) -> NDArray[np.float64] | tuple[NDArray[np.float64], NDArray[np.int64]]: ...
+@overload
+def get_coordinates(
+    geometry: OptGeoArrayLike, include_z: bool, return_index: bool
+) -> NDArray[np.float64] | tuple[NDArray[np.float64], NDArray[np.int64]]: ...
+@overload
+def set_coordinates(geometry: GeoT, coordinates: ArrayLikeSeq[float]) -> GeoT: ...
+@overload
+def set_coordinates(geometry: OptGeoArrayLikeSeq, coordinates: ArrayLikeSeq[float]) -> GeoArray: ...

stubs/shapely/shapely/coords.pyi

@@ -0,0 +1,18 @@
+from array import array
+from collections.abc import Iterator
+from typing import overload
+
+import numpy as np
+from numpy.typing import DTypeLike, NDArray
+
+class CoordinateSequence:
+    def __init__(self, coords: NDArray[np.float64]) -> None: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[tuple[float, float]]: ...
+    @overload
+    def __getitem__(self, key: int) -> tuple[float, float]: ...
+    @overload
+    def __getitem__(self, key: slice) -> list[tuple[float, float]]: ...
+    def __array__(self, dtype: DTypeLike | None = None) -> NDArray[np.float64]: ...
+    @property
+    def xy(self) -> tuple[array[float], array[float]]: ...

stubs/shapely/shapely/creation.pyi

@@ -0,0 +1,242 @@
+from collections.abc import Sequence
+from typing import Literal, SupportsIndex, overload
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ._geometry import GeometryType
+from ._typing import ArrayLike, ArrayLikeSeq, GeoArray, OptGeoArrayLike, OptGeoArrayLikeSeq
+from .geometry import GeometryCollection, LinearRing, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon
+from .lib import Geometry
+
+__all__ = [
+    "points",
+    "linestrings",
+    "linearrings",
+    "polygons",
+    "multipoints",
+    "multilinestrings",
+    "multipolygons",
+    "geometrycollections",
+    "box",
+    "prepare",
+    "destroy_prepared",
+    "empty",
+]
+
+@overload
+def points(
+    coords: float, y: float, z: float | None = None, indices: None = None, out: None = None, **kwargs  # acts as x
+) -> Point: ...
+@overload
+def points(
+    coords: Sequence[float], y: None = None, z: None = None, indices: None = None, out: None = None, **kwargs  # acts as x, y[, z]
+) -> Point: ...
+@overload
+def points(
+    coords: Sequence[float],  # acts as (x1, x2, ...)
+    y: Sequence[float],  # must be (y1, y2, ...)
+    z: Sequence[float] | None = None,
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def points(
+    coords: Sequence[Sequence[float]],  # acts as (x1, x2, ...), (y1, y2, ...)[, (z1, z2, ...)]
+    y: None = None,
+    z: None = None,
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def points(
+    coords: ArrayLike[float],
+    y: ArrayLike[float],
+    z: ArrayLike[float] | None = None,
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> Point | GeoArray: ...
+@overload
+def points(
+    coords: ArrayLikeSeq[float],
+    y: ArrayLike[float] | None = None,
+    z: ArrayLike[float] | None = None,
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> Point | GeoArray: ...
+@overload
+def linestrings(
+    coords: Sequence[float],  # acts as (x1, x2, ...)
+    y: Sequence[float],
+    z: Sequence[float] | None = None,
+    indices: None = None,
+    out: None = None,
+    **kwargs,
+) -> LineString: ...
+@overload
+def linestrings(
+    coords: Sequence[Sequence[float]],  # acts as (x1, y1[, z1]), (x2, y2[, z2]), ...
+    y: None = None,
+    z: None = None,
+    indices: None = None,
+    out: None = None,
+    **kwargs,
+) -> LineString: ...
+@overload
+def linestrings(
+    coords: Sequence[Sequence[Sequence[float]]],  # acts as seq of (x1, y1[, z1]), (x2, y2[, z2]), ...
+    y: None = None,
+    z: None = None,
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def linestrings(
+    coords: ArrayLikeSeq[float],
+    y: ArrayLikeSeq[float] | None = None,
+    z: ArrayLikeSeq[float] | None = None,
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> LineString | GeoArray: ...
+@overload
+def linearrings(
+    coords: Sequence[float],  # acts as (x1, x2, ...)
+    y: Sequence[float],
+    z: Sequence[float] | None = None,
+    indices: None = None,
+    out: None = None,
+    **kwargs,
+) -> LinearRing: ...
+@overload
+def linearrings(
+    coords: Sequence[Sequence[float]],  # acts as (x1, y1[, z1]), (x2, y2[, z2]), ...
+    y: None = None,
+    z: None = None,
+    indices: None = None,
+    out: None = None,
+    **kwargs,
+) -> LinearRing: ...
+@overload
+def linearrings(
+    coords: Sequence[Sequence[Sequence[float]]],  # acts as seq of (x1, y1[, z1]), (x2, y2[, z2]), ...
+    y: None = None,
+    z: None = None,
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def linearrings(
+    coords: ArrayLikeSeq[float],
+    y: ArrayLikeSeq[float] | None = None,
+    z: ArrayLikeSeq[float] | None = None,
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> LinearRing | GeoArray: ...
+@overload
+def polygons(
+    geometries: LinearRing | Sequence[Sequence[float]] | None,
+    holes: ArrayLikeSeq[float] | OptGeoArrayLikeSeq | None = None,
+    indices: None = None,
+    out: None = None,
+    **kwargs,
+) -> Polygon: ...
+@overload
+def polygons(
+    geometries: Sequence[LinearRing | Sequence[Sequence[float]] | None],
+    holes: ArrayLikeSeq[float] | OptGeoArrayLikeSeq | None = None,
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def polygons(
+    geometries: ArrayLikeSeq[float] | OptGeoArrayLikeSeq,
+    holes: ArrayLikeSeq[float] | OptGeoArrayLikeSeq | None = None,
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> Polygon | GeoArray: ...
+@overload
+def box(xmin: float, ymin: float, xmax: float, ymax: float, ccw: bool = True, **kwargs) -> Polygon: ...
+@overload
+def box(
+    xmin: ArrayLikeSeq[float],
+    ymin: ArrayLikeSeq[float],
+    xmax: ArrayLikeSeq[float],
+    ymax: ArrayLikeSeq[float],
+    ccw: bool = True,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def multipoints(
+    geometries: Sequence[Point | Sequence[float] | None], indices: None = None, out: None = None, **kwargs
+) -> MultiPoint: ...
+@overload
+def multipoints(
+    geometries: Sequence[Sequence[Point | Sequence[float] | None]],
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def multipoints(
+    geometries: OptGeoArrayLikeSeq, indices: ArrayLikeSeq[int] | None = None, out: NDArray[np.object_] | None = None, **kwargs
+) -> MultiPoint | GeoArray: ...
+@overload
+def multilinestrings(
+    geometries: Sequence[LineString | Sequence[Sequence[float]] | None], indices: None = None, out: None = None, **kwargs
+) -> MultiLineString: ...
+@overload
+def multilinestrings(
+    geometries: Sequence[Sequence[LineString | Sequence[Sequence[float]] | None]],
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def multilinestrings(
+    geometries: OptGeoArrayLikeSeq, indices: ArrayLikeSeq[int] | None = None, out: NDArray[np.object_] | None = None, **kwargs
+) -> MultiLineString | GeoArray: ...
+@overload
+def multipolygons(
+    geometries: Sequence[Polygon | Sequence[Sequence[float]] | None], indices: None = None, out: None = None, **kwargs
+) -> MultiPolygon: ...
+@overload
+def multipolygons(
+    geometries: Sequence[Sequence[Polygon | Sequence[Sequence[float]] | None]],
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def multipolygons(
+    geometries: OptGeoArrayLikeSeq, indices: ArrayLikeSeq[int] | None = None, out: NDArray[np.object_] | None = None, **kwargs
+) -> MultiPolygon | GeoArray: ...
+@overload
+def geometrycollections(
+    geometries: Sequence[Geometry | None], indices: None = None, out: None = None, **kwargs
+) -> GeometryCollection: ...
+@overload
+def geometrycollections(
+    geometries: Sequence[Sequence[Geometry | None]],
+    indices: ArrayLikeSeq[int] | None = None,
+    out: NDArray[np.object_] | None = None,
+    **kwargs,
+) -> GeoArray: ...
+@overload
+def geometrycollections(
+    geometries: OptGeoArrayLikeSeq, indices: ArrayLikeSeq[int] | None = None, out: NDArray[np.object_] | None = None, **kwargs
+) -> GeometryCollection | GeoArray: ...
+def prepare(geometry: OptGeoArrayLike, **kwargs) -> None: ...
+def destroy_prepared(geometry: OptGeoArrayLike, **kwargs) -> None: ...
+def empty(
+    shape: SupportsIndex | Sequence[SupportsIndex], geom_type: GeometryType | int | None = None, order: Literal["C", "F"] = "C"
+) -> NDArray[np.object_]: ...

stubs/shapely/shapely/decorators.pyi

@@ -0,0 +1,11 @@
+from collections.abc import Callable
+from typing import TypeVar
+
+_F = TypeVar("_F", bound=Callable[..., object])
+
+class requires_geos:
+    version: tuple[int, int, int]
+    def __init__(self, version: str) -> None: ...
+    def __call__(self, func: _F) -> _F: ...
+
+def multithreading_enabled(func: _F) -> _F: ...

stubs/shapely/shapely/errors.pyi

@@ -0,0 +1,17 @@
+from .lib import GEOSException as GEOSException, ShapelyError as ShapelyError
+
+def setup_signal_checks(interval: int = 10000) -> None: ...
+
+class UnsupportedGEOSVersionError(ShapelyError): ...
+class DimensionError(ShapelyError): ...
+class TopologicalError(ShapelyError): ...
+class ShapelyDeprecationWarning(FutureWarning): ...
+class EmptyPartError(ShapelyError): ...
+class GeometryTypeError(ShapelyError): ...
+
+# deprecated aliases
+ReadingError = ShapelyError
+WKBReadingError = ShapelyError
+WKTReadingError = ShapelyError
+PredicateError = ShapelyError
+InvalidGeometryError = ShapelyError

stubs/shapely/shapely/geometry/__init__.pyi

@@ -0,0 +1,25 @@
+from .base import CAP_STYLE as CAP_STYLE, JOIN_STYLE as JOIN_STYLE
+from .collection import GeometryCollection as GeometryCollection
+from .geo import box as box, mapping as mapping, shape as shape
+from .linestring import LineString as LineString
+from .multilinestring import MultiLineString as MultiLineString
+from .multipoint import MultiPoint as MultiPoint
+from .multipolygon import MultiPolygon as MultiPolygon
+from .point import Point as Point
+from .polygon import LinearRing as LinearRing, Polygon as Polygon
+
+__all__ = [
+    "box",
+    "shape",
+    "mapping",
+    "Point",
+    "LineString",
+    "Polygon",
+    "MultiPoint",
+    "MultiLineString",
+    "MultiPolygon",
+    "GeometryCollection",
+    "LinearRing",
+    "CAP_STYLE",
+    "JOIN_STYLE",
+]

stubs/shapely/shapely/geometry/base.pyi

@@ -0,0 +1,285 @@
+from array import array
+from collections.abc import Iterator
+from typing import Any, Generic, Literal, NoReturn, overload
+from typing_extensions import Self, TypeVar, deprecated  # noqa: Y023
+
+import numpy as np
+from numpy.typing import NDArray
+
+from .._typing import ArrayLikeSeq, GeoArray, GeoT, OptGeoArrayLike, OptGeoArrayLikeSeq
+from ..constructive import BufferCapStyle, BufferJoinStyle
+from ..coords import CoordinateSequence
+from ..lib import Geometry
+from .collection import GeometryCollection
+from .point import Point
+from .polygon import Polygon
+
+GEOMETRY_TYPES: list[str]
+
+@deprecated("Function 'geom_factory' is deprecated.")
+def geom_factory(g: int, parent: object | None = None) -> Any: ...
+def dump_coords(geom: Geometry) -> list[tuple[float, float] | list[tuple[float, float]]]: ...
+
+class CAP_STYLE:
+    round: Literal[BufferCapStyle.round]
+    flat: Literal[BufferCapStyle.flat]
+    square: Literal[BufferCapStyle.square]
+
+class JOIN_STYLE:
+    round: Literal[BufferJoinStyle.round]
+    mitre: Literal[BufferJoinStyle.mitre]
+    bevel: Literal[BufferJoinStyle.bevel]
+
+class BaseGeometry(Geometry):
+    @deprecated(
+        "Directly calling 'BaseGeometry()' is deprecated. To create an empty geometry, "
+        "use one of the subclasses instead, for example 'GeometryCollection()'."  # pyright: ignore[reportImplicitStringConcatenation]
+    )
+    def __new__(self) -> GeometryCollection: ...
+    def __bool__(self) -> bool: ...
+    def __nonzero__(self) -> bool: ...
+    def __format__(self, format_spec: str) -> str: ...
+    @overload
+    def __and__(self, other: Geometry) -> BaseGeometry: ...
+    @overload
+    def __and__(self, other: OptGeoArrayLikeSeq) -> GeoArray: ...
+    @overload
+    def __and__(self, other: None) -> None: ...
+    @overload
+    def __or__(self, other: Geometry) -> BaseGeometry: ...
+    @overload
+    def __or__(self, other: OptGeoArrayLikeSeq) -> GeoArray: ...
+    @overload
+    def __or__(self, other: None) -> None: ...
+    @overload
+    def __sub__(self, other: Geometry) -> BaseGeometry: ...
+    @overload
+    def __sub__(self, other: OptGeoArrayLikeSeq) -> GeoArray: ...
+    @overload
+    def __sub__(self, other: None) -> None: ...
+    @overload
+    def __xor__(self, other: Geometry) -> BaseGeometry: ...
+    @overload
+    def __xor__(self, other: OptGeoArrayLikeSeq) -> GeoArray: ...
+    @overload
+    def __xor__(self, other: None) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    @property
+    def coords(self) -> CoordinateSequence: ...
+    @property
+    def xy(self) -> tuple[array[float], array[float]]: ...
+    @property
+    def __geo_interface__(self) -> dict[str, Any]: ...
+    @deprecated("Method 'geometryType()' is deprecated. Use attribute 'geom_type' instead.")
+    def geometryType(self) -> str: ...
+    @property
+    @deprecated("Attribute 'type' is deprecated. Use attribute 'geom_type' instead.")
+    def type(self) -> str: ...
+    @property
+    def wkt(self) -> str: ...
+    @property
+    def wkb(self) -> bytes: ...
+    @property
+    def wkb_hex(self) -> str: ...
+    def svg(self, scale_factor: float = 1.0, **kwargs) -> str: ...
+    def _repr_svg_(self) -> str: ...
+    @property
+    def geom_type(self) -> str: ...
+    @property
+    def area(self) -> float: ...
+    @overload
+    def distance(self, other: Geometry | None) -> float: ...
+    @overload
+    def distance(self, other: OptGeoArrayLikeSeq) -> NDArray[np.float64]: ...
+    @overload
+    def hausdorff_distance(self, other: Geometry | None) -> float: ...
+    @overload
+    def hausdorff_distance(self, other: OptGeoArrayLikeSeq) -> NDArray[np.float64]: ...
+    @property
+    def length(self) -> float: ...
+    @property
+    def minimum_clearance(self) -> float: ...
+    @property
+    def boundary(self) -> BaseMultipartGeometry | Any: ...  # is None for GeometryCollection
+    @property
+    def bounds(self) -> tuple[float, float, float, float]: ...
+    @property
+    def centroid(self) -> Point: ...
+    def point_on_surface(self) -> Point: ...
+    def representative_point(self) -> Point: ...
+    @property
+    def convex_hull(self) -> BaseGeometry: ...
+    @property
+    def envelope(self) -> BaseGeometry: ...
+    @property
+    def oriented_envelope(self) -> BaseGeometry: ...
+    @property
+    def minimum_rotated_rectangle(self) -> BaseGeometry: ...
+    def buffer(
+        self,
+        distance: float,
+        quad_segs: int = 16,
+        cap_style: BufferCapStyle | Literal["round", "square", "flat"] = "round",
+        join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = "round",
+        mitre_limit: float = 5.0,
+        single_sided: bool = False,
+        *,
+        quadsegs: int | None = None,  # deprecated
+        resolution: int | None = None,  # to be deprecated
+    ) -> Polygon: ...
+    def simplify(self, tolerance: float, preserve_topology: bool = True) -> BaseGeometry: ...
+    def normalize(self) -> BaseGeometry: ...
+    @overload
+    def difference(self, other: Geometry, grid_size: float | None = None) -> BaseGeometry: ...
+    @overload
+    def difference(self, other: OptGeoArrayLikeSeq, grid_size: float | None = None) -> GeoArray: ...
+    @overload
+    def difference(self, other: None, grid_size: float | None = None) -> None: ...
+    @overload
+    def intersection(self, other: Geometry, grid_size: float | None = None) -> BaseGeometry: ...
+    @overload
+    def intersection(self, other: OptGeoArrayLikeSeq, grid_size: float | None = None) -> GeoArray: ...
+    @overload
+    def intersection(self, other: None, grid_size: float | None = None) -> None: ...
+    @overload
+    def symmetric_difference(self, other: Geometry, grid_size: float | None = None) -> BaseGeometry: ...
+    @overload
+    def symmetric_difference(self, other: OptGeoArrayLikeSeq, grid_size: float | None = None) -> GeoArray: ...
+    @overload
+    def symmetric_difference(self, other: None, grid_size: float | None = None) -> None: ...
+    @overload
+    def union(self, other: Geometry, grid_size: float | None = None) -> BaseGeometry: ...
+    @overload
+    def union(self, other: OptGeoArrayLikeSeq, grid_size: float | None = None) -> GeoArray: ...
+    @overload
+    def union(self, other: None, grid_size: float | None = None) -> None: ...
+    @property
+    def has_z(self) -> bool: ...
+    @property
+    def is_empty(self) -> bool: ...
+    @property
+    def is_ring(self) -> bool: ...
+    @property
+    def is_closed(self) -> bool: ...
+    @property
+    def is_simple(self) -> bool: ...
+    @property
+    def is_valid(self) -> bool: ...
+    @overload
+    def relate(self, other: Geometry) -> str: ...
+    @overload
+    def relate(self, other: OptGeoArrayLikeSeq) -> NDArray[np.str_]: ...
+    @overload
+    def relate(self, other: None) -> None: ...
+    @overload
+    def covers(self, other: Geometry | None) -> bool: ...
+    @overload
+    def covers(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def covered_by(self, other: Geometry | None) -> bool: ...
+    @overload
+    def covered_by(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def contains(self, other: Geometry | None) -> bool: ...
+    @overload
+    def contains(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def contains_properly(self, other: Geometry | None) -> bool: ...
+    @overload
+    def contains_properly(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def crosses(self, other: Geometry | None) -> bool: ...
+    @overload
+    def crosses(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def disjoint(self, other: Geometry | None) -> bool: ...
+    @overload
+    def disjoint(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def equals(self, other: Geometry | None) -> bool: ...
+    @overload
+    def equals(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def intersects(self, other: Geometry | None) -> bool: ...
+    @overload
+    def intersects(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def overlaps(self, other: Geometry | None) -> bool: ...
+    @overload
+    def overlaps(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def touches(self, other: Geometry | None) -> bool: ...
+    @overload
+    def touches(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def within(self, other: Geometry | None) -> bool: ...
+    @overload
+    def within(self, other: OptGeoArrayLikeSeq) -> NDArray[np.bool_]: ...
+    @overload
+    def dwithin(self, other: Geometry | None, distance: float) -> bool: ...
+    @overload
+    def dwithin(self, other: OptGeoArrayLikeSeq, distance: float) -> NDArray[np.bool_]: ...
+    @overload
+    def dwithin(self, other: OptGeoArrayLike, distance: ArrayLikeSeq[float]) -> NDArray[np.bool_]: ...
+    @overload
+    def equals_exact(self, other: Geometry | None, tolerance: float) -> bool: ...
+    @overload
+    def equals_exact(self, other: OptGeoArrayLikeSeq, tolerance: float) -> NDArray[np.bool_]: ...
+    @overload
+    def equals_exact(self, other: OptGeoArrayLike, tolerance: ArrayLikeSeq[float]) -> NDArray[np.bool_]: ...
+    @deprecated("Method 'almost_equals()' is deprecated. Use method 'equals_exact()' instead.")
+    def almost_equals(self, other: OptGeoArrayLike, decimal: int = 6) -> bool | NDArray[np.bool_]: ...
+    @overload
+    def relate_pattern(self, other: Geometry | None, pattern: str) -> bool: ...
+    @overload
+    def relate_pattern(self, other: OptGeoArrayLikeSeq, pattern: str) -> NDArray[np.bool_]: ...
+    @overload
+    def line_locate_point(self, other: Point | None, normalized: bool = False) -> float: ...
+    @overload
+    def line_locate_point(self, other: OptGeoArrayLikeSeq, normalized: bool = False) -> NDArray[np.float64]: ...
+    @overload
+    def project(self, other: Point | None, normalized: bool = False) -> float: ...
+    @overload
+    def project(self, other: OptGeoArrayLikeSeq, normalized: bool = False) -> NDArray[np.float64]: ...
+    @overload
+    def line_interpolate_point(self, distance: float, normalized: bool = False) -> Point: ...
+    @overload
+    def line_interpolate_point(self, distance: ArrayLikeSeq[float], normalized: bool = False) -> GeoArray: ...
+    @overload
+    def interpolate(self, distance: float, normalized: bool = False) -> Point: ...
+    @overload
+    def interpolate(self, distance: ArrayLikeSeq[float], normalized: bool = False) -> GeoArray: ...
+    @overload
+    def segmentize(self, max_segment_length: float) -> Self: ...
+    @overload
+    def segmentize(self, max_segment_length: ArrayLikeSeq[float]) -> GeoArray: ...
+    def reverse(self) -> Self: ...
+
+_GeoT_co = TypeVar("_GeoT_co", bound=Geometry, default=BaseGeometry, covariant=True)
+
+class BaseMultipartGeometry(BaseGeometry, Generic[_GeoT_co]):
+    @property
+    def coords(self) -> NoReturn: ...
+    @property
+    def geoms(self) -> GeometrySequence[Self]: ...
+    def svg(self, scale_factor: float = 1.0, color: str | None = None) -> str: ...  # type: ignore[override]
+
+_P_co = TypeVar("_P_co", covariant=True, bound=BaseMultipartGeometry[Geometry])
+
+class GeometrySequence(Generic[_P_co]):
+    def __init__(self, parent: _P_co) -> None: ...
+    def __iter__(self: GeometrySequence[BaseMultipartGeometry[GeoT]]) -> Iterator[GeoT]: ...
+    def __len__(self) -> int: ...
+    @overload
+    def __getitem__(self: GeometrySequence[BaseMultipartGeometry[GeoT]], key: int | np.integer[Any]) -> GeoT: ...
+    @overload
+    def __getitem__(self, key: slice) -> _P_co: ...
+
+class EmptyGeometry(BaseGeometry):
+    @deprecated(
+        "The 'EmptyGeometry()' constructor is deprecated. Use one of the "
+        "geometry subclasses instead, for example 'GeometryCollection()'."  # pyright: ignore[reportImplicitStringConcatenation]
+    )
+    def __new__(self) -> GeometryCollection: ...  # type: ignore[misc]

stubs/shapely/shapely/geometry/collection.pyi

@@ -0,0 +1,18 @@
+from collections.abc import Collection
+from typing import overload
+from typing_extensions import Self
+
+from .._typing import OptGeoArrayLike
+from .base import BaseMultipartGeometry, GeometrySequence, _GeoT_co
+
+class GeometryCollection(BaseMultipartGeometry[_GeoT_co]):
+    # Overloads of __new__ are used because mypy is unable to narrow the typevar otherwise
+    @overload
+    def __new__(
+        self, geoms: BaseMultipartGeometry[_GeoT_co] | GeometrySequence[BaseMultipartGeometry[_GeoT_co]] | Collection[_GeoT_co]
+    ) -> Self: ...
+    @overload
+    def __new__(self, geoms: OptGeoArrayLike = None) -> Self: ...
+    # more precise base overrides
+    @property
+    def boundary(self) -> None: ...

stubs/shapely/shapely/geometry/geo.pyi

@@ -0,0 +1,9 @@
+from typing import Any
+
+from .._typing import SupportsGeoInterface
+from .base import BaseGeometry
+from .polygon import Polygon
+
+def box(minx: float, miny: float, maxx: float, maxy: float, ccw: bool = True) -> Polygon: ...
+def shape(context: dict[str, Any] | SupportsGeoInterface) -> BaseGeometry: ...
+def mapping(ob: SupportsGeoInterface) -> dict[str, Any]: ...

stubs/shapely/shapely/geometry/linestring.pyi

@@ -0,0 +1,45 @@
+from collections.abc import Iterable
+from typing import Literal, SupportsFloat, SupportsIndex
+from typing_extensions import Self, TypeAlias
+
+from .._typing import ArrayLikeSeq
+from ..constructive import BufferJoinStyle
+from .base import BaseGeometry
+from .multilinestring import MultiLineString
+from .multipoint import MultiPoint
+from .point import Point
+from .polygon import Polygon
+
+__all__ = ["LineString"]
+
+_ConvertibleToLineString: TypeAlias = LineString | ArrayLikeSeq[float] | Iterable[Point | Iterable[SupportsFloat]]
+
+class LineString(BaseGeometry):
+    def __new__(self, coordinates: _ConvertibleToLineString | None = None) -> Self: ...
+    def svg(self, scale_factor: float = 1.0, stroke_color: str | None = None, opacity: float | None = None) -> str: ...  # type: ignore[override]
+    def offset_curve(
+        self,
+        distance: float,
+        quad_segs: SupportsIndex = 16,
+        join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = ...,
+        mitre_limit: float = 5.0,
+    ) -> LineString | MultiLineString: ...
+    def parallel_offset(  # to be deprecated
+        self,
+        distance: float,
+        side: str = "right",
+        resolution: SupportsIndex = 16,
+        join_style: BufferJoinStyle | Literal["round", "mitre", "bevel"] = ...,
+        mitre_limit: float = 5.0,
+    ) -> LineString | MultiLineString: ...
+    # more precise base overrides
+    @property
+    def boundary(self) -> MultiPoint: ...
+    @property
+    def convex_hull(self) -> LineString: ...
+    @property
+    def envelope(self) -> Polygon: ...
+    @property
+    def oriented_envelope(self) -> LineString: ...
+    @property
+    def minimum_rotated_rectangle(self) -> LineString: ...

stubs/shapely/shapely/geometry/multilinestring.pyi

@@ -0,0 +1,15 @@
+from collections.abc import Collection
+from typing_extensions import Self
+
+from .base import BaseMultipartGeometry
+from .linestring import LineString, _ConvertibleToLineString
+from .multipoint import MultiPoint
+
+__all__ = ["MultiLineString"]
+
+class MultiLineString(BaseMultipartGeometry[LineString]):
+    def __new__(self, lines: BaseMultipartGeometry | Collection[_ConvertibleToLineString] | None = None) -> Self: ...
+    def svg(self, scale_factor: float = 1.0, stroke_color: str | None = None, opacity: float | None = None) -> str: ...  # type: ignore[override]
+    # more precise base overrides
+    @property
+    def boundary(self) -> MultiPoint: ...

stubs/shapely/shapely/geometry/multipoint.pyi

@@ -0,0 +1,20 @@
+from collections.abc import Collection
+from typing_extensions import Self
+
+from .base import BaseMultipartGeometry
+from .collection import GeometryCollection
+from .point import Point, _PointLike
+
+__all__ = ["MultiPoint"]
+
+class MultiPoint(BaseMultipartGeometry[Point]):
+    # Note on "points" type in `__new__`:
+    # * `Collection` here is loose as the expected type should support "__getitem__".
+    # * `Sequence` is more correct but it will lead to False positives with common types
+    #   like np.ndarray, pd.Index, pd.Series, ...
+    # I went with Collection as false negatives seem better to me than false positives in this case
+    def __new__(self, points: MultiPoint | Collection[_PointLike] | None = None) -> Self: ...
+    def svg(self, scale_factor: float = 1.0, fill_color: str | None = None, opacity: float | None = None) -> str: ...  # type: ignore[override]
+    # more precise base overrides
+    @property
+    def boundary(self) -> GeometryCollection: ...  # empty geometry collection

stubs/shapely/shapely/geometry/multipolygon.pyi

@@ -0,0 +1,22 @@
+from collections.abc import Collection
+from typing_extensions import Self
+
+from .base import BaseMultipartGeometry
+from .multilinestring import MultiLineString
+from .polygon import Polygon, _PolygonHolesLike, _PolygonShellLike
+
+__all__ = ["MultiPolygon"]
+
+class MultiPolygon(BaseMultipartGeometry[Polygon]):
+    def __new__(
+        self,
+        polygons: (
+            BaseMultipartGeometry
+            | Collection[Polygon | tuple[_PolygonShellLike] | tuple[_PolygonShellLike, _PolygonHolesLike] | None]
+            | None
+        ) = None,
+    ) -> Self: ...
+    def svg(self, scale_factor: float = 1.0, fill_color: str | None = None, opacity: float | None = None) -> str: ...  # type: ignore[override]
+    # more precise base overrides
+    @property
+    def boundary(self) -> MultiLineString: ...

stubs/shapely/shapely/geometry/point.pyi

@@ -0,0 +1,39 @@
+from collections.abc import Iterable
+from typing import overload
+from typing_extensions import Self, TypeAlias
+
+from .._typing import ArrayLikeSeq
+from .base import BaseGeometry
+from .collection import GeometryCollection
+
+__all__ = ["Point"]
+
+_PointLike: TypeAlias = Point | Iterable[float] | ArrayLikeSeq[float]
+
+class Point(BaseGeometry):
+    @overload  # no args: empty point
+    def __new__(self) -> Self: ...
+    @overload  # one arg: (x, y[, z]) tuple or a Point instance
+    def __new__(self, coords: _PointLike, /) -> Self: ...
+    @overload  # two args: (x, y) tuple
+    def __new__(self, x: float, y: float, /) -> Self: ...
+    @overload  # three args: (x, y, z) tuple
+    def __new__(self, x: float, y: float, z: float, /) -> Self: ...
+    @property
+    def x(self) -> float: ...
+    @property
+    def y(self) -> float: ...
+    @property
+    def z(self) -> float: ...
+    def svg(self, scale_factor: float = 1.0, fill_color: str | None = None, opacity: float | None = None) -> str: ...  # type: ignore[override]
+    # more precise base overrides
+    @property
+    def boundary(self) -> GeometryCollection: ...  # empty geometry collection
+    @property
+    def convex_hull(self) -> Point: ...
+    @property
+    def envelope(self) -> Point: ...
+    @property
+    def oriented_envelope(self) -> Point: ...
+    @property
+    def minimum_rotated_rectangle(self) -> Point: ...

stubs/shapely/shapely/geometry/polygon.pyi

@@ -0,0 +1,45 @@
+from collections.abc import Collection
+from typing import NoReturn, overload
+from typing_extensions import Self, TypeAlias
+
+from .base import BaseGeometry
+from .linestring import LineString, _ConvertibleToLineString
+from .multilinestring import MultiLineString
+
+__all__ = ["orient", "Polygon", "LinearRing"]
+
+_ConvertibleToLinearRing: TypeAlias = _ConvertibleToLineString  # same alias but with better name for doc purposes
+_PolygonShellLike: TypeAlias = Polygon | _ConvertibleToLinearRing | None
+_PolygonHolesLike: TypeAlias = Collection[_ConvertibleToLinearRing | None] | None
+
+class LinearRing(LineString):
+    def __new__(self, coordinates: _ConvertibleToLinearRing | None = None) -> Self: ...
+    @property
+    def is_ccw(self) -> bool: ...
+
+class InteriorRingSequence:
+    def __init__(self, parent: Polygon) -> None: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> LinearRing: ...
+    def __len__(self) -> int: ...
+    @overload
+    def __getitem__(self, key: int) -> LinearRing: ...
+    @overload
+    def __getitem__(self, key: slice) -> list[LinearRing]: ...
+
+class Polygon(BaseGeometry):
+    def __new__(self, shell: _PolygonShellLike = None, holes: _PolygonHolesLike = None) -> Self: ...
+    @property
+    def exterior(self) -> LinearRing: ...
+    @property
+    def interiors(self) -> list[LinearRing] | InteriorRingSequence: ...
+    @property
+    def coords(self) -> NoReturn: ...
+    def svg(self, scale_factor: float = 1.0, fill_color: str | None = None, opacity: float | None = None) -> str: ...  # type: ignore[override]
+    @classmethod
+    def from_bounds(cls, xmin: float, ymin: float, xmax: float, ymax: float) -> Self: ...
+    # more precise base overrides
+    @property
+    def boundary(self) -> MultiLineString: ...
+
+def orient(polygon: Polygon, sign: float = 1.0) -> Polygon: ...

stubs/shapely/shapely/geos.pyi

@@ -0,0 +1,3 @@
+geos_version_string: str
+geos_version: tuple[int, int, int]
+geos_capi_version: tuple[int, int, int]

stubs/shapely/shapely/io.pyi

@@ -0,0 +1,140 @@
+from _typeshed import Incomplete
+from typing import Literal, overload
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ._enum import ParamEnum
+from ._ragged_array import from_ragged_array as from_ragged_array, to_ragged_array as to_ragged_array
+from ._typing import ArrayLikeSeq, GeoArray, OptGeoArrayLikeSeq
+from .geometry.base import BaseGeometry
+from .lib import Geometry
+
+__all__ = ["from_geojson", "from_ragged_array", "from_wkb", "from_wkt", "to_geojson", "to_ragged_array", "to_wkb", "to_wkt"]
+
+# Mypy and stubtest aren't happy with the following definition and
+# raise is a reserved keyword, so we cannot use the class syntax of enums
+# DecodingErrorOptions = ParamEnum("DecodingErrorOptions", {"ignore": 0, "warn": 1, "raise": 2})
+DecodingErrorOptions: Incomplete
+
+class WKBFlavorOptions(ParamEnum):
+    extended = 1  # noqa: Y052
+    iso = 2  # noqa: Y052
+
+@overload
+def to_wkt(
+    geometry: None, rounding_precision: int = 6, trim: bool = True, output_dimension: int = 3, old_3d: bool = False, **kwargs
+) -> None: ...
+@overload
+def to_wkt(
+    geometry: Geometry, rounding_precision: int = 6, trim: bool = True, output_dimension: int = 3, old_3d: bool = False, **kwargs
+) -> str: ...
+@overload
+def to_wkt(
+    geometry: OptGeoArrayLikeSeq,
+    rounding_precision: int = 6,
+    trim: bool = True,
+    output_dimension: int = 3,
+    old_3d: bool = False,
+    **kwargs,
+) -> NDArray[np.str_]: ...
+@overload
+def to_wkb(
+    geometry: None,
+    hex: bool = False,
+    output_dimension: int = 3,
+    byte_order: int = -1,
+    include_srid: bool = False,
+    flavor: Literal["iso", "extended"] = "extended",
+    **kwargs,
+) -> None: ...
+@overload
+def to_wkb(
+    geometry: Geometry,
+    hex: Literal[False] = False,
+    output_dimension: int = 3,
+    byte_order: int = -1,
+    include_srid: bool = False,
+    flavor: Literal["iso", "extended"] = "extended",
+    **kwargs,
+) -> bytes: ...
+@overload
+def to_wkb(
+    geometry: Geometry,
+    hex: Literal[True],
+    output_dimension: int = 3,
+    byte_order: int = -1,
+    include_srid: bool = False,
+    flavor: Literal["iso", "extended"] = "extended",
+    **kwargs,
+) -> str: ...
+@overload
+def to_wkb(
+    geometry: Geometry,
+    hex: bool,
+    output_dimension: int = 3,
+    byte_order: int = -1,
+    include_srid: bool = False,
+    flavor: Literal["iso", "extended"] = "extended",
+    **kwargs,
+) -> bytes | str: ...
+@overload
+def to_wkb(
+    geometry: OptGeoArrayLikeSeq,
+    hex: Literal[False] = False,
+    output_dimension: int = 3,
+    byte_order: int = -1,
+    include_srid: bool = False,
+    flavor: Literal["iso", "extended"] = "extended",
+    **kwargs,
+) -> NDArray[np.bytes_]: ...
+@overload
+def to_wkb(
+    geometry: OptGeoArrayLikeSeq,
+    hex: Literal[True],
+    output_dimension: int = 3,
+    byte_order: int = -1,
+    include_srid: bool = False,
+    flavor: Literal["iso", "extended"] = "extended",
+    **kwargs,
+) -> NDArray[np.str_]: ...
+@overload
+def to_wkb(
+    geometry: OptGeoArrayLikeSeq,
+    hex: bool,
+    output_dimension: int = 3,
+    byte_order: int = -1,
+    include_srid: bool = False,
+    flavor: Literal["iso", "extended"] = "extended",
+    **kwargs,
+) -> NDArray[np.bytes_] | NDArray[np.str_]: ...
+@overload
+def to_geojson(geometry: None, indent: int | None = None, **kwargs) -> None: ...
+@overload
+def to_geojson(geometry: Geometry, indent: int | None = None, **kwargs) -> str: ...
+@overload
+def to_geojson(geometry: OptGeoArrayLikeSeq, indent: int | None = None, **kwargs) -> NDArray[np.str_]: ...
+@overload
+def from_wkt(geometry: None, on_invalid: Literal["raise", "warn", "ignore"] = "raise", **kwargs) -> None: ...
+@overload
+def from_wkt(geometry: str, on_invalid: Literal["raise", "warn", "ignore"] = "raise", **kwargs) -> BaseGeometry: ...  # type: ignore[overload-overlap]
+@overload
+def from_wkt(
+    geometry: ArrayLikeSeq[str | None], on_invalid: Literal["raise", "warn", "ignore"] = "raise", **kwargs
+) -> GeoArray: ...
+@overload
+def from_wkb(geometry: None, on_invalid: Literal["raise", "warn", "ignore"] = "raise", **kwargs) -> None: ...
+@overload
+def from_wkb(geometry: str | bytes, on_invalid: Literal["raise", "warn", "ignore"] = "raise", **kwargs) -> BaseGeometry: ...  # type: ignore[overload-overlap]
+@overload
+def from_wkb(
+    geometry: ArrayLikeSeq[str | bytes | None], on_invalid: Literal["raise", "warn", "ignore"] = "raise", **kwargs
+) -> GeoArray: ...
+@overload
+def from_geojson(geometry: None, on_invalid: Literal["raise", "warn", "ignore"] = "raise", **kwargs) -> None: ...
+@overload
+def from_geojson(geometry: str | bytes, on_invalid: Literal["raise", "warn", "ignore"] = "raise", **kwargs) -> BaseGeometry: ...  # type: ignore[overload-overlap]
+@overload
+def from_geojson(
+    geometry: ArrayLikeSeq[str | bytes | None], on_invalid: Literal["raise", "warn", "ignore"] = "raise", **kwargs
+) -> GeoArray: ...

stubs/shapely/shapely/lib.pyi

@@ -0,0 +1,167 @@
+from typing import Literal, SupportsIndex, final, overload
+from typing_extensions import Never
+
+import numpy as np
+from numpy.typing import NDArray
+
+area: np.ufunc
+boundary: np.ufunc
+bounds: np.ufunc
+box: np.ufunc
+buffer: np.ufunc
+build_area: np.ufunc
+centroid: np.ufunc
+clip_by_rect: np.ufunc
+concave_hull: np.ufunc
+contains: np.ufunc
+contains_properly: np.ufunc
+contains_xy: np.ufunc
+convex_hull: np.ufunc
+coverage_union: np.ufunc
+covered_by: np.ufunc
+covers: np.ufunc
+create_collection: np.ufunc
+crosses: np.ufunc
+delaunay_triangles: np.ufunc
+destroy_prepared: np.ufunc
+difference: np.ufunc
+difference_prec: np.ufunc
+disjoint: np.ufunc
+distance: np.ufunc
+dwithin: np.ufunc
+envelope: np.ufunc
+equals: np.ufunc
+equals_exact: np.ufunc
+extract_unique_points: np.ufunc
+force_2d: np.ufunc
+force_3d: np.ufunc
+frechet_distance: np.ufunc
+frechet_distance_densify: np.ufunc
+from_geojson: np.ufunc
+from_wkb: np.ufunc
+from_wkt: np.ufunc
+get_coordinate_dimension: np.ufunc
+get_dimensions: np.ufunc
+get_exterior_ring: np.ufunc
+get_geometry: np.ufunc
+get_interior_ring: np.ufunc
+get_num_coordinates: np.ufunc
+get_num_geometries: np.ufunc
+get_num_interior_rings: np.ufunc
+get_num_points: np.ufunc
+get_point: np.ufunc
+get_precision: np.ufunc
+get_srid: np.ufunc
+get_type_id: np.ufunc
+get_x: np.ufunc
+get_y: np.ufunc
+get_z: np.ufunc
+has_z: np.ufunc
+hausdorff_distance: np.ufunc
+hausdorff_distance_densify: np.ufunc
+intersection: np.ufunc
+intersection_all: np.ufunc
+intersection_prec: np.ufunc
+intersects: np.ufunc
+intersects_xy: np.ufunc
+is_ccw: np.ufunc
+is_closed: np.ufunc
+is_empty: np.ufunc
+is_geometry: np.ufunc
+is_missing: np.ufunc
+is_prepared: np.ufunc
+is_ring: np.ufunc
+is_simple: np.ufunc
+is_valid: np.ufunc
+is_valid_input: np.ufunc
+is_valid_reason: np.ufunc
+length: np.ufunc
+line_interpolate_point: np.ufunc
+line_interpolate_point_normalized: np.ufunc
+line_locate_point: np.ufunc
+line_locate_point_normalized: np.ufunc
+line_merge: np.ufunc
+line_merge_directed: np.ufunc
+linearrings: np.ufunc
+linestrings: np.ufunc
+make_valid: np.ufunc
+minimum_bounding_circle: np.ufunc
+minimum_bounding_radius: np.ufunc
+minimum_clearance: np.ufunc
+node: np.ufunc
+normalize: np.ufunc
+offset_curve: np.ufunc
+oriented_envelope: np.ufunc
+overlaps: np.ufunc
+point_on_surface: np.ufunc
+points: np.ufunc
+polygonize: np.ufunc
+polygonize_full: np.ufunc
+polygons: np.ufunc
+prepare: np.ufunc
+relate: np.ufunc
+relate_pattern: np.ufunc
+remove_repeated_points: np.ufunc
+reverse: np.ufunc
+segmentize: np.ufunc
+set_precision: np.ufunc
+set_srid: np.ufunc
+shared_paths: np.ufunc
+shortest_line: np.ufunc
+simplify: np.ufunc
+simplify_preserve_topology: np.ufunc
+snap: np.ufunc
+symmetric_difference: np.ufunc
+symmetric_difference_all: np.ufunc
+symmetric_difference_prec: np.ufunc
+to_geojson: np.ufunc
+to_wkb: np.ufunc
+to_wkt: np.ufunc
+touches: np.ufunc
+unary_union: np.ufunc
+unary_union_prec: np.ufunc
+union: np.ufunc
+union_prec: np.ufunc
+voronoi_polygons: np.ufunc
+within: np.ufunc
+geos_capi_version: tuple[int, int, int]
+geos_capi_version_string: str
+geos_version: tuple[int, int, int]
+geos_version_string: str
+registry: list[type[Geometry]]
+
+class Geometry:
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __ge__(self, other: Never) -> bool: ...
+    def __gt__(self, other: Never) -> bool: ...
+    def __le__(self, other: Never) -> bool: ...
+    def __lt__(self, other: Never) -> bool: ...
+
+@final
+class STRtree:
+    count: int
+    def __init__(self, geoms: NDArray[np.object_], node_capacity: SupportsIndex, /, **kwargs: object) -> None: ...
+    def dwithin(self, geoms: NDArray[np.object_], distances: NDArray[np.float64], /) -> NDArray[np.int64]: ...
+    def nearest(self, geoms: NDArray[np.object_], /) -> NDArray[np.int64]: ...
+    def query(self, geoms: NDArray[np.object_], predicate: SupportsIndex, /) -> NDArray[np.int64]: ...
+    def query_nearest(
+        self, geoms: NDArray[np.object_], max_distance: float, exclusive: SupportsIndex, all_matches: SupportsIndex, /
+    ) -> tuple[NDArray[np.int64], NDArray[np.float64]]: ...
+
+class ShapelyError(Exception): ...
+class GEOSException(ShapelyError): ...
+
+def count_coordinates(geoms: NDArray[np.object_], /) -> int: ...
+@overload
+def get_coordinates(arr: NDArray[np.object_], include_z: bool, return_index: Literal[False], /) -> NDArray[np.float64]: ...
+@overload
+def get_coordinates(
+    arr: NDArray[np.object_], include_z: bool, return_index: Literal[True], /
+) -> tuple[NDArray[np.float64], NDArray[np.int64]]: ...
+@overload
+def get_coordinates(
+    arr: NDArray[np.object_], include_z: bool, return_index: bool, /
+) -> NDArray[np.float64] | tuple[NDArray[np.float64], NDArray[np.int64]]: ...
+def set_coordinates(geoms: NDArray[np.object_], coords: NDArray[np.float64], /) -> NDArray[np.object_]: ...

stubs/shapely/shapely/linear.pyi

@@ -0,0 +1,69 @@
+from typing import overload
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ._typing import ArrayLike, ArrayLikeSeq, GeoArray, OptGeoArrayLike, OptGeoArrayLikeSeq
+from .geometry import GeometryCollection, LineString, MultiLineString, Point
+from .lib import Geometry
+
+__all__ = ["line_interpolate_point", "line_locate_point", "line_merge", "shared_paths", "shortest_line"]
+
+@overload
+def line_interpolate_point(line: None, distance: float, normalized: bool = False, **kwargs) -> None: ...
+@overload
+def line_interpolate_point(
+    line: None, distance: ArrayLikeSeq[float], normalized: bool = False, **kwargs
+) -> NDArray[np.object_]: ...  # Array of None
+@overload
+def line_interpolate_point(
+    line: LineString | MultiLineString | GeometryCollection, distance: float, normalized: bool = False, **kwargs
+) -> Point: ...
+@overload
+def line_interpolate_point(
+    line: LineString | MultiLineString | GeometryCollection, distance: ArrayLikeSeq[float], normalized: bool = False, **kwargs
+) -> GeoArray: ...
+@overload
+def line_interpolate_point(
+    line: OptGeoArrayLikeSeq, distance: ArrayLike[float], normalized: bool = False, **kwargs
+) -> GeoArray: ...
+@overload
+def line_locate_point(
+    line: LineString | MultiLineString | GeometryCollection | None, other: Point | None, normalized: bool = False, **kwargs
+) -> float: ...
+@overload
+def line_locate_point(
+    line: LineString | MultiLineString | GeometryCollection | None, other: OptGeoArrayLikeSeq, normalized: bool = False, **kwargs
+) -> NDArray[np.float64]: ...
+@overload
+def line_locate_point(
+    line: OptGeoArrayLikeSeq, other: OptGeoArrayLike, normalized: bool = False, **kwargs
+) -> NDArray[np.float64]: ...
+@overload
+def line_merge(line: None, directed: bool = False, **kwargs) -> None: ...
+@overload
+def line_merge(line: Geometry, directed: bool = False, **kwargs) -> LineString | MultiLineString | GeometryCollection: ...
+@overload
+def line_merge(line: OptGeoArrayLikeSeq, directed: bool = False, **kwargs) -> GeoArray: ...
+@overload
+def shared_paths(a: LineString | MultiLineString | None, b: None, **kwargs) -> None: ...
+@overload
+def shared_paths(a: None, b: LineString | MultiLineString | None, **kwargs) -> None: ...
+@overload
+def shared_paths(
+    a: LineString | MultiLineString, b: LineString | MultiLineString, **kwargs
+) -> GeometryCollection[MultiLineString]: ...
+@overload
+def shared_paths(a: LineString | MultiLineString | None, b: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def shared_paths(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> GeoArray: ...
+@overload
+def shortest_line(a: Geometry | None, b: None, **kwargs) -> None: ...
+@overload
+def shortest_line(a: None, b: Geometry | None, **kwargs) -> None: ...
+@overload
+def shortest_line(a: Geometry, b: Geometry, **kwargs) -> LineString: ...
+@overload
+def shortest_line(a: Geometry | None, b: OptGeoArrayLikeSeq, **kwargs) -> GeoArray: ...
+@overload
+def shortest_line(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> GeoArray: ...

stubs/shapely/shapely/measurement.pyi

@@ -0,0 +1,68 @@
+from typing import overload
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ._typing import ArrayLike, ArrayLikeSeq, OptGeoArrayLike, OptGeoArrayLikeSeq
+from .lib import Geometry
+
+__all__ = [
+    "area",
+    "distance",
+    "bounds",
+    "total_bounds",
+    "length",
+    "hausdorff_distance",
+    "frechet_distance",
+    "minimum_clearance",
+    "minimum_bounding_radius",
+]
+
+@overload
+def area(geometry: Geometry | None, **kwargs) -> float: ...
+@overload
+def area(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.float64]: ...
+@overload
+def distance(a: Geometry | None, b: Geometry | None, **kwargs) -> float: ...
+@overload
+def distance(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.float64]: ...
+@overload
+def distance(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.float64]: ...
+def bounds(geometry: OptGeoArrayLike, **kwargs) -> NDArray[np.float64]: ...
+def total_bounds(geometry: OptGeoArrayLike, **kwargs) -> NDArray[np.float64]: ...
+@overload
+def length(geometry: Geometry | None, **kwargs) -> float: ...
+@overload
+def length(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.float64]: ...
+@overload
+def hausdorff_distance(a: Geometry | None, b: Geometry | None, densify: float | None = None, **kwargs) -> float: ...
+@overload
+def hausdorff_distance(a: OptGeoArrayLike, b: OptGeoArrayLike, densify: ArrayLikeSeq[float], **kwargs) -> NDArray[np.float64]: ...
+@overload
+def hausdorff_distance(
+    a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, densify: ArrayLike[float] | None = None, **kwargs
+) -> NDArray[np.float64]: ...
+@overload
+def hausdorff_distance(
+    a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, densify: ArrayLike[float] | None = None, **kwargs
+) -> NDArray[np.float64]: ...
+@overload
+def frechet_distance(a: Geometry | None, b: Geometry | None, densify: float | None = None, **kwargs) -> float: ...
+@overload
+def frechet_distance(a: OptGeoArrayLike, b: OptGeoArrayLike, densify: ArrayLikeSeq[float], **kwargs) -> NDArray[np.float64]: ...
+@overload
+def frechet_distance(
+    a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, densify: ArrayLike[float] | None = None, **kwargs
+) -> NDArray[np.float64]: ...
+@overload
+def frechet_distance(
+    a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, densify: ArrayLike[float] | None = None, **kwargs
+) -> NDArray[np.float64]: ...
+@overload
+def minimum_clearance(geometry: Geometry | None, **kwargs) -> float: ...
+@overload
+def minimum_clearance(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.float64]: ...
+@overload
+def minimum_bounding_radius(geometry: Geometry | None, **kwargs) -> float: ...
+@overload
+def minimum_bounding_radius(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.float64]: ...

stubs/shapely/shapely/ops.pyi

@@ -0,0 +1,106 @@
+from collections.abc import Callable, Iterable
+from typing import Any, Literal, overload
+from typing_extensions import deprecated
+
+from ._typing import GeoT, OptGeoArrayLike, SupportsGeoInterface
+from .algorithms.polylabel import polylabel as polylabel
+from .geometry import GeometryCollection, LineString, MultiLineString, Point, Polygon
+from .geometry.base import BaseGeometry, BaseMultipartGeometry, GeometrySequence
+from .geometry.linestring import _ConvertibleToLineString
+from .lib import Geometry
+
+__all__ = [
+    "cascaded_union",
+    "linemerge",
+    "operator",
+    "polygonize",
+    "polygonize_full",
+    "transform",
+    "unary_union",
+    "triangulate",
+    "voronoi_diagram",
+    "split",
+    "nearest_points",
+    "validate",
+    "snap",
+    "shared_paths",
+    "clip_by_rect",
+    "orient",
+    "substring",
+]
+
+class CollectionOperator:
+    @overload
+    def shapeup(self, ob: GeoT) -> GeoT: ...  # type: ignore[overload-overlap]
+    @overload
+    def shapeup(self, ob: dict[str, Any] | SupportsGeoInterface) -> BaseGeometry: ...  # type: ignore[overload-overlap]
+    @overload
+    def shapeup(self, ob: _ConvertibleToLineString) -> LineString: ...
+    def polygonize(
+        self, lines: OptGeoArrayLike | Iterable[_ConvertibleToLineString | None]
+    ) -> GeometrySequence[GeometryCollection[Polygon]]: ...
+    def polygonize_full(
+        self, lines: OptGeoArrayLike | Iterable[_ConvertibleToLineString | None]
+    ) -> tuple[
+        GeometryCollection[Polygon], GeometryCollection[LineString], GeometryCollection[LineString], GeometryCollection[Polygon]
+    ]: ...
+    def linemerge(
+        self, lines: MultiLineString | BaseMultipartGeometry | Iterable[_ConvertibleToLineString], directed: bool = False
+    ) -> LineString | MultiLineString: ...
+    @deprecated("The `cascaded_union()` function is deprecated. Use `unary_union()` instead.")
+    def cascaded_union(self, geoms: OptGeoArrayLike) -> BaseGeometry: ...
+    def unary_union(self, geoms: OptGeoArrayLike) -> BaseGeometry: ...
+
+operator: CollectionOperator
+polygonize = operator.polygonize
+polygonize_full = operator.polygonize_full
+linemerge = operator.linemerge
+unary_union = operator.unary_union
+
+# This is also an alias to operator method but we want to mark it as deprecated
+@deprecated("The `cascaded_union()` function is deprecated. Use `unary_union()` instead.")
+def cascaded_union(geoms: OptGeoArrayLike) -> BaseGeometry: ...
+@overload  # edges false
+def triangulate(geom: Geometry, tolerance: float = 0.0, edges: Literal[False] = False) -> list[Polygon]: ...
+@overload  # edges true (keyword)
+def triangulate(geom: Geometry, tolerance: float = 0.0, *, edges: Literal[True]) -> list[LineString]: ...
+@overload  # edges true (positional)
+def triangulate(geom: Geometry, tolerance: float, edges: Literal[True]) -> list[LineString]: ...
+@overload  # fallback
+def triangulate(geom: Geometry, tolerance: float = 0.0, edges: bool = False) -> list[Polygon] | list[LineString]: ...
+@overload
+def voronoi_diagram(
+    geom: Geometry, envelope: Geometry | None = None, tolerance: float = 0.0, edges: Literal[False] = False
+) -> GeometryCollection[Polygon]: ...
+@overload
+def voronoi_diagram(
+    geom: Geometry, envelope: Geometry | None, tolerance: float, edges: Literal[True]
+) -> GeometryCollection[LineString | MultiLineString]: ...
+@overload
+def voronoi_diagram(
+    geom: Geometry, envelope: Geometry | None = None, tolerance: float = 0.0, *, edges: Literal[True]
+) -> GeometryCollection[LineString | MultiLineString]: ...
+@overload
+def voronoi_diagram(
+    geom: Geometry, envelope: Geometry | None = None, tolerance: float = 0.0, edges: bool = False
+) -> GeometryCollection[Polygon | LineString | MultiLineString]: ...
+@overload
+def validate(geom: None) -> None: ...
+@overload
+def validate(geom: Geometry) -> str: ...
+@overload
+def validate(geom: Geometry | None) -> str | None: ...
+def transform(func: Callable[[float, float, float | None], tuple[float, ...]], geom: GeoT) -> GeoT: ...
+def nearest_points(g1: Geometry, g2: Geometry) -> tuple[Point, Point]: ...
+def snap(g1: GeoT, g2: Geometry, tolerance: float) -> GeoT: ...
+def shared_paths(g1: LineString, g2: LineString) -> GeometryCollection[MultiLineString]: ...
+
+class SplitOp:
+    @staticmethod
+    def split(geom: Geometry, splitter: Geometry) -> GeometryCollection: ...
+
+split = SplitOp.split
+
+def substring(geom: LineString, start_dist: float, end_dist: float, normalized: bool = False) -> Point | LineString: ...
+def clip_by_rect(geom: Geometry, xmin: float, ymin: float, xmax: float, ymax: float) -> BaseGeometry: ...
+def orient(geom: GeoT, sign: float = 1.0) -> GeoT: ...

stubs/shapely/shapely/plotting.pyi

@@ -0,0 +1,76 @@
+from typing import Any, Literal, overload
+
+from matplotlib.axes import Axes  # type: ignore[import-not-found]
+from matplotlib.lines import Line2D  # type: ignore[import-not-found]
+from matplotlib.patches import PathPatch  # type: ignore[import-not-found]
+from matplotlib.typing import ColorType  # type: ignore[import-not-found]
+
+from .geometry import LinearRing, LineString, MultiLineString, MultiPolygon, Polygon
+from .lib import Geometry
+
+def patch_from_polygon(polygon: Polygon | MultiPolygon, **kwargs: Any) -> PathPatch: ...
+@overload
+def plot_polygon(
+    polygon: Polygon | MultiPolygon,
+    ax: Axes | None = None,
+    add_points: Literal[True] = True,
+    color: ColorType | None = None,
+    facecolor: ColorType | None = None,
+    edgecolor: ColorType | None = None,
+    linewidth: float | None = None,
+    **kwargs: Any,
+) -> tuple[PathPatch, Line2D]: ...
+@overload
+def plot_polygon(
+    polygon: Polygon | MultiPolygon,
+    ax: Axes | None = None,
+    *,
+    add_points: Literal[False],
+    color: ColorType | None = None,
+    facecolor: ColorType | None = None,
+    edgecolor: ColorType | None = None,
+    linewidth: float | None = None,
+    **kwargs: Any,
+) -> PathPatch: ...
+@overload
+def plot_polygon(
+    polygon: Polygon | MultiPolygon,
+    ax: Axes | None,
+    add_points: Literal[False],
+    color: ColorType | None = None,
+    facecolor: ColorType | None = None,
+    edgecolor: ColorType | None = None,
+    linewidth: float | None = None,
+    **kwargs: Any,
+) -> PathPatch: ...
+@overload
+def plot_line(
+    line: LineString | LinearRing | MultiLineString,
+    ax: Axes | None = None,
+    add_points: Literal[True] = True,
+    color: ColorType | None = None,
+    linewidth: float = 2,
+    **kwargs: Any,
+) -> tuple[PathPatch, Line2D]: ...
+@overload
+def plot_line(
+    line: LineString | LinearRing | MultiLineString,
+    ax: Axes | None = None,
+    *,
+    add_points: Literal[False],
+    color: ColorType | None = None,
+    linewidth: float = 2,
+    **kwargs: Any,
+) -> PathPatch: ...
+@overload
+def plot_line(
+    line: LineString | LinearRing | MultiLineString,
+    ax: Axes | None,
+    add_points: Literal[False],
+    color: ColorType | None = None,
+    linewidth: float = 2,
+    **kwargs: Any,
+) -> PathPatch: ...
+def plot_points(
+    geom: Geometry, ax: Axes | None = None, color: ColorType | None = None, marker: str = "o", **kwargs: Any
+) -> Line2D: ...

stubs/shapely/shapely/predicates.pyi

@@ -0,0 +1,214 @@
+from typing import Any, Literal, overload
+from typing_extensions import TypeGuard
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ._typing import ArrayLike, ArrayLikeSeq, OptGeoArrayLike, OptGeoArrayLikeSeq
+from .geometry.base import BaseGeometry
+from .lib import Geometry
+
+__all__ = [
+    "has_z",
+    "is_ccw",
+    "is_closed",
+    "is_empty",
+    "is_geometry",
+    "is_missing",
+    "is_prepared",
+    "is_ring",
+    "is_simple",
+    "is_valid",
+    "is_valid_input",
+    "is_valid_reason",
+    "crosses",
+    "contains",
+    "contains_xy",
+    "contains_properly",
+    "covered_by",
+    "covers",
+    "disjoint",
+    "dwithin",
+    "equals",
+    "intersects",
+    "intersects_xy",
+    "overlaps",
+    "touches",
+    "within",
+    "equals_exact",
+    "relate",
+    "relate_pattern",
+]
+
+@overload
+def has_z(geometry: Geometry | None, **kwargs) -> bool: ...
+@overload
+def has_z(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def is_ccw(geometry: Geometry | None, **kwargs) -> bool: ...
+@overload
+def is_ccw(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def is_closed(geometry: Geometry | None, **kwargs) -> bool: ...
+@overload
+def is_closed(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def is_empty(geometry: Geometry | None, **kwargs) -> bool: ...
+@overload
+def is_empty(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def is_geometry(geometry: Geometry, **kwargs) -> Literal[True]: ...
+@overload
+def is_geometry(geometry: ArrayLikeSeq[Any], **kwargs) -> NDArray[np.bool_]: ...  # type: ignore[overload-overlap]
+@overload
+def is_geometry(geometry: object, **kwargs) -> TypeGuard[BaseGeometry]: ...
+@overload
+def is_missing(geometry: Geometry, **kwargs) -> Literal[True]: ...
+@overload
+def is_missing(geometry: ArrayLikeSeq[Any], **kwargs) -> NDArray[np.bool_]: ...  # type: ignore[overload-overlap]
+@overload
+def is_missing(geometry: object, **kwargs) -> TypeGuard[BaseGeometry]: ...
+@overload
+def is_prepared(geometry: Geometry | None, **kwargs) -> bool: ...
+@overload
+def is_prepared(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def is_valid_input(geometry: Geometry | None, **kwargs) -> Literal[True]: ...
+@overload
+def is_valid_input(geometry: ArrayLikeSeq[Any], **kwargs) -> NDArray[np.bool_]: ...  # type: ignore[overload-overlap]
+@overload
+def is_valid_input(geometry: object, **kwargs) -> TypeGuard[BaseGeometry | None]: ...
+@overload
+def is_ring(geometry: Geometry | None, **kwargs) -> bool: ...
+@overload
+def is_ring(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def is_simple(geometry: Geometry | None, **kwargs) -> bool: ...
+@overload
+def is_simple(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def is_valid(geometry: Geometry | None, **kwargs) -> bool: ...
+@overload
+def is_valid(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def is_valid_reason(geometry: None, **kwargs) -> None: ...
+@overload
+def is_valid_reason(geometry: Geometry, **kwargs) -> str: ...
+@overload
+def is_valid_reason(geometry: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.object_]: ...
+@overload
+def crosses(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def crosses(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def crosses(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def contains(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def contains(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def contains(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def contains_properly(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def contains_properly(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def contains_properly(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def covered_by(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def covered_by(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def covered_by(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def covers(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def covers(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def covers(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def disjoint(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def disjoint(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def disjoint(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def equals(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def equals(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def equals(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def intersects(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def intersects(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def intersects(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def overlaps(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def overlaps(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def overlaps(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def touches(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def touches(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def touches(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def within(a: Geometry | None, b: Geometry | None, **kwargs) -> bool: ...
+@overload
+def within(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def within(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def equals_exact(a: Geometry | None, b: Geometry | None, tolerance: float = 0.0, **kwargs) -> bool: ...
+@overload
+def equals_exact(a: OptGeoArrayLike, b: OptGeoArrayLike, tolerance: ArrayLikeSeq[float], **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def equals_exact(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, tolerance: ArrayLike[float] = 0.0, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def equals_exact(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, tolerance: ArrayLike[float] = 0.0, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def relate(a: Geometry | None, b: None, **kwargs) -> None: ...
+@overload
+def relate(a: None, b: Geometry | None, **kwargs) -> None: ...
+@overload
+def relate(a: Geometry, b: Geometry, **kwargs) -> str: ...
+@overload
+def relate(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, **kwargs) -> NDArray[np.object_]: ...
+@overload
+def relate(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, **kwargs) -> NDArray[np.object_]: ...
+@overload
+def relate_pattern(a: Geometry | None, b: Geometry | None, pattern: str, **kwargs) -> bool: ...
+@overload
+def relate_pattern(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, pattern: str, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def relate_pattern(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, pattern: str, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def dwithin(a: Geometry | None, b: Geometry | None, distance: float, **kwargs) -> bool: ...
+@overload
+def dwithin(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, distance: float, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def dwithin(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, distance: float, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def contains_xy(geom: Geometry | None, x: float, y: float, **kwargs) -> bool: ...
+@overload
+def contains_xy(geom: OptGeoArrayLike, x: ArrayLikeSeq[float], y: None = None, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def contains_xy(geom: Geometry | None, x: ArrayLike[float], y: ArrayLikeSeq[float], **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def contains_xy(geom: Geometry | None, x: ArrayLikeSeq[float], y: ArrayLike[float], **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def contains_xy(geom: OptGeoArrayLikeSeq, x: ArrayLike[float], y: ArrayLike[float], **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def intersects_xy(geom: Geometry | None, x: float, y: float, **kwargs) -> bool: ...
+@overload
+def intersects_xy(geom: OptGeoArrayLike, x: ArrayLikeSeq[float], y: None = None, **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def intersects_xy(geom: Geometry | None, x: ArrayLike[float], y: ArrayLikeSeq[float], **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def intersects_xy(geom: Geometry | None, x: ArrayLikeSeq[float], y: ArrayLike[float], **kwargs) -> NDArray[np.bool_]: ...
+@overload
+def intersects_xy(geom: OptGeoArrayLikeSeq, x: ArrayLike[float], y: ArrayLike[float], **kwargs) -> NDArray[np.bool_]: ...

stubs/shapely/shapely/prepared.pyi

@@ -0,0 +1,20 @@
+from typing import Generic, Literal
+
+from ._typing import GeoT
+from .lib import Geometry
+
+class PreparedGeometry(Generic[GeoT]):
+    context: GeoT
+    prepared: Literal[True]
+    def __init__(self, context: GeoT | PreparedGeometry[GeoT]) -> None: ...
+    def contains(self, other: Geometry | None) -> bool: ...
+    def contains_properly(self, other: Geometry | None) -> bool: ...
+    def covers(self, other: Geometry | None) -> bool: ...
+    def crosses(self, other: Geometry | None) -> bool: ...
+    def disjoint(self, other: Geometry | None) -> bool: ...
+    def intersects(self, other: Geometry | None) -> bool: ...
+    def overlaps(self, other: Geometry | None) -> bool: ...
+    def touches(self, other: Geometry | None) -> bool: ...
+    def within(self, other: Geometry | None) -> bool: ...
+
+def prep(ob: GeoT | PreparedGeometry[GeoT]) -> PreparedGeometry[GeoT]: ...

stubs/shapely/shapely/set_operations.pyi

@@ -0,0 +1,86 @@
+from typing import overload
+
+from ._typing import GeoArray, OptGeoArrayLike, OptGeoArrayLikeSeq
+from .geometry.base import BaseGeometry
+from .lib import Geometry
+
+__all__ = [
+    "difference",
+    "intersection",
+    "intersection_all",
+    "symmetric_difference",
+    "symmetric_difference_all",
+    "unary_union",
+    "union",
+    "union_all",
+    "coverage_union",
+    "coverage_union_all",
+]
+
+@overload
+def difference(a: Geometry, b: Geometry, grid_size: float | None = None, **kwargs) -> BaseGeometry: ...
+@overload
+def difference(a: None, b: Geometry | None, grid_size: float | None = None, **kwargs) -> None: ...
+@overload
+def difference(a: Geometry | None, b: None, grid_size: float | None = None, **kwargs) -> None: ...
+@overload
+def difference(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, grid_size: float | None = None, **kwargs) -> GeoArray: ...
+@overload
+def difference(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, grid_size: float | None = None, **kwargs) -> GeoArray: ...
+@overload
+def intersection(a: Geometry, b: Geometry, grid_size: float | None = None, **kwargs) -> BaseGeometry: ...
+@overload
+def intersection(a: None, b: Geometry | None, grid_size: float | None = None, **kwargs) -> None: ...
+@overload
+def intersection(a: Geometry | None, b: None, grid_size: float | None = None, **kwargs) -> None: ...
+@overload
+def intersection(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, grid_size: float | None = None, **kwargs) -> GeoArray: ...
+@overload
+def intersection(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, grid_size: float | None = None, **kwargs) -> GeoArray: ...
+@overload
+def intersection_all(geometries: OptGeoArrayLike, axis: None = None, **kwargs) -> BaseGeometry: ...
+@overload
+def intersection_all(geometries: OptGeoArrayLikeSeq, axis: int, **kwargs) -> BaseGeometry | GeoArray: ...
+@overload
+def symmetric_difference(a: Geometry, b: Geometry, grid_size: float | None = None, **kwargs) -> BaseGeometry: ...
+@overload
+def symmetric_difference(a: None, b: Geometry | None, grid_size: float | None = None, **kwargs) -> None: ...
+@overload
+def symmetric_difference(a: Geometry | None, b: None, grid_size: float | None = None, **kwargs) -> None: ...
+@overload
+def symmetric_difference(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, grid_size: float | None = None, **kwargs) -> GeoArray: ...
+@overload
+def symmetric_difference(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, grid_size: float | None = None, **kwargs) -> GeoArray: ...
+@overload
+def symmetric_difference_all(geometries: OptGeoArrayLike, axis: None = None, **kwargs) -> BaseGeometry: ...
+@overload
+def symmetric_difference_all(geometries: OptGeoArrayLikeSeq, axis: int, **kwargs) -> BaseGeometry | GeoArray: ...
+@overload
+def union(a: Geometry, b: Geometry, grid_size: float | None = None, **kwargs) -> BaseGeometry: ...
+@overload
+def union(a: None, b: Geometry | None, grid_size: float | None = None, **kwargs) -> None: ...
+@overload
+def union(a: Geometry | None, b: None, grid_size: float | None = None, **kwargs) -> None: ...
+@overload
+def union(a: OptGeoArrayLikeSeq, b: OptGeoArrayLike, grid_size: float | None = None, **kwargs) -> GeoArray: ...
+@overload
+def union(a: OptGeoArrayLike, b: OptGeoArrayLikeSeq, grid_size: float | None = None, **kwargs) -> GeoArray: ...
+@overload
+def union_all(geometries: OptGeoArrayLike, grid_size: float | None = None, axis: None = None, **kwargs) -> BaseGeometry: ...
+@overload
+def union_all(
+    geometries: OptGeoArrayLikeSeq, grid_size: float | None = None, *, axis: int, **kwargs
+) -> BaseGeometry | GeoArray: ...
+@overload
+def union_all(geometries: OptGeoArrayLikeSeq, grid_size: float | None, axis: int, **kwargs) -> BaseGeometry | GeoArray: ...
+
+unary_union = union_all
+
+@overload
+def coverage_union(a: OptGeoArrayLike, b: OptGeoArrayLike, *, axis: None = None, **kwargs) -> BaseGeometry: ...
+@overload
+def coverage_union(a: OptGeoArrayLike, b: OptGeoArrayLike, *, axis: int, **kwargs) -> BaseGeometry | GeoArray: ...
+@overload
+def coverage_union_all(geometries: OptGeoArrayLike, axis: None = None, **kwargs) -> BaseGeometry: ...
+@overload
+def coverage_union_all(geometries: OptGeoArrayLikeSeq, axis: int, **kwargs) -> BaseGeometry | GeoArray: ...

stubs/shapely/shapely/speedups.pyi

@@ -0,0 +1,12 @@
+from typing import Final
+from typing_extensions import deprecated
+
+__all__ = ["available", "enable", "disable", "enabled"]
+
+available: Final = True
+enabled: Final = True
+
+@deprecated("Function `enable` is deprecated and no longer has any effect. Speedups are always available.")
+def enable() -> None: ...
+@deprecated("Function `disable` is deprecated and no longer has any effect. Speedups are always available.")
+def disable() -> None: ...

stubs/shapely/shapely/strtree.pyi

@@ -0,0 +1,82 @@
+from typing import Any, Literal, SupportsIndex, overload
+from typing_extensions import TypeAlias
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ._enum import ParamEnum
+from ._typing import ArrayLike, GeoArray, GeoArrayLikeSeq, OptGeoArrayLike
+from .lib import Geometry
+
+__all__ = ["STRtree"]
+
+_BinaryPredicate: TypeAlias = Literal[
+    "intersects", "within", "contains", "overlaps", "crosses", "touches", "covers", "covered_by", "contains_properly"
+]
+
+class BinaryPredicate(ParamEnum):
+    intersects: int
+    within: int
+    contains: int
+    overlaps: int
+    crosses: int
+    touches: int
+    covers: int
+    covered_by: int
+    contains_properly: int
+
+class STRtree:
+    def __init__(self, geoms: GeoArrayLikeSeq, node_capacity: SupportsIndex = 10) -> None: ...
+    def __len__(self) -> int: ...
+    @property
+    def geometries(self) -> GeoArray: ...
+    @overload
+    def query(
+        self, geometry: OptGeoArrayLike, predicate: Literal["dwithin"], distance: ArrayLike[float]
+    ) -> NDArray[np.int64]: ...
+    @overload
+    def query(
+        self, geometry: OptGeoArrayLike, predicate: _BinaryPredicate | None = None, distance: object = None
+    ) -> NDArray[np.int64]: ...
+    # nearest may return `None` if the tree is empty, use the "Any trick"
+    @overload
+    def nearest(self, geometry: Geometry) -> int | Any: ...
+    @overload
+    def nearest(self, geometry: GeoArrayLikeSeq) -> NDArray[np.int64] | Any: ...
+    @overload  # return_distance=False
+    def query_nearest(
+        self,
+        geometry: OptGeoArrayLike,
+        max_distance: float | None = None,
+        return_distance: Literal[False] = False,
+        exclusive: bool = False,
+        all_matches: bool = True,
+    ) -> NDArray[np.int64]: ...
+    @overload  # return_distance=True keyword
+    def query_nearest(
+        self,
+        geometry: OptGeoArrayLike,
+        max_distance: float | None = None,
+        *,
+        return_distance: Literal[True],
+        exclusive: bool = False,
+        all_matches: bool = True,
+    ) -> tuple[NDArray[np.int64], NDArray[np.float64]]: ...
+    @overload  # return_distance=True positional
+    def query_nearest(
+        self,
+        geometry: OptGeoArrayLike,
+        max_distance: float | None,
+        return_distance: Literal[True],
+        exclusive: bool = False,
+        all_matches: bool = True,
+    ) -> tuple[NDArray[np.int64], NDArray[np.float64]]: ...
+    @overload  # return_distance=bool fallback
+    def query_nearest(
+        self,
+        geometry: OptGeoArrayLike,
+        max_distance: float | None = None,
+        return_distance: bool = False,
+        exclusive: bool = False,
+        all_matches: bool = True,
+    ) -> NDArray[np.int64] | tuple[NDArray[np.int64], NDArray[np.float64]]: ...

stubs/shapely/shapely/testing.pyi

@@ -0,0 +1,14 @@
+from ._typing import ArrayLike, OptGeoArrayLike
+
+__all__ = ["assert_geometries_equal"]
+
+def assert_geometries_equal(
+    x: OptGeoArrayLike,
+    y: OptGeoArrayLike,
+    tolerance: ArrayLike[float] = 1e-7,
+    equal_none: bool = True,
+    equal_nan: bool = True,
+    normalize: bool = False,
+    err_msg: str = "",
+    verbose: bool = True,
+) -> None: ...

stubs/shapely/shapely/validation.pyi

@@ -0,0 +1,7 @@
+from .geometry.base import BaseGeometry
+from .lib import Geometry
+
+__all__ = ["explain_validity", "make_valid"]
+
+def explain_validity(ob: Geometry) -> str: ...
+def make_valid(ob: Geometry) -> BaseGeometry: ...

stubs/shapely/shapely/vectorized/__init__.pyi

@@ -0,0 +1,37 @@
+from typing import overload
+
+import numpy as np
+from numpy.typing import NDArray
+
+from .._typing import ArrayLike, ArrayLikeSeq
+from ..lib import Geometry
+from ..prepared import PreparedGeometry
+
+@overload
+def contains(geometry: Geometry | PreparedGeometry[Geometry], x: float, y: float) -> bool: ...
+@overload
+def contains(
+    geometry: Geometry | PreparedGeometry[Geometry], x: ArrayLikeSeq[float], y: ArrayLike[float]
+) -> NDArray[np.bool_]: ...
+@overload
+def contains(
+    geometry: Geometry | PreparedGeometry[Geometry], x: ArrayLike[float], y: ArrayLikeSeq[float]
+) -> NDArray[np.bool_]: ...
+@overload
+def contains(
+    geometry: Geometry | PreparedGeometry[Geometry], x: ArrayLike[float], y: ArrayLike[float]
+) -> bool | NDArray[np.bool_]: ...
+@overload
+def touches(geometry: Geometry | PreparedGeometry[Geometry], x: float, y: float) -> bool: ...
+@overload
+def touches(
+    geometry: Geometry | PreparedGeometry[Geometry], x: ArrayLikeSeq[float], y: ArrayLike[float]
+) -> NDArray[np.bool_]: ...
+@overload
+def touches(
+    geometry: Geometry | PreparedGeometry[Geometry], x: ArrayLike[float], y: ArrayLikeSeq[float]
+) -> NDArray[np.bool_]: ...
+@overload
+def touches(
+    geometry: Geometry | PreparedGeometry[Geometry], x: ArrayLike[float], y: ArrayLike[float]
+) -> bool | NDArray[np.bool_]: ...

stubs/shapely/shapely/wkb.pyi

@@ -0,0 +1,16 @@
+from _typeshed import SupportsRead, SupportsWrite
+from typing import Literal, overload
+
+from .geometry.base import BaseGeometry
+from .lib import Geometry
+
+def loads(data: str | bytes, hex: bool = False) -> BaseGeometry: ...
+def load(fp: SupportsRead[str] | SupportsRead[bytes], hex: bool = False) -> BaseGeometry: ...
+@overload
+def dumps(ob: Geometry, hex: Literal[False] = False, srid: int | None = None, **kw) -> bytes: ...
+@overload
+def dumps(ob: Geometry, hex: Literal[True], srid: int | None = None, **kw) -> str: ...
+@overload
+def dump(ob: Geometry, fp: SupportsWrite[bytes], hex: Literal[False] = False, *, srid: int | None = None, **kw) -> None: ...
+@overload
+def dump(ob: Geometry, fp: SupportsWrite[str], hex: Literal[True], *, srid: int | None = None, **kw) -> None: ...

stubs/shapely/shapely/wkt.pyi

@@ -0,0 +1,9 @@
+from _typeshed import SupportsRead, SupportsWrite
+
+from .geometry.base import BaseGeometry
+from .lib import Geometry
+
+def loads(data: str) -> BaseGeometry: ...
+def load(fp: SupportsRead[str]) -> BaseGeometry: ...
+def dumps(ob: Geometry, trim: bool = False, rounding_precision: int = -1, **kw) -> str: ...
+def dump(ob: Geometry, fp: SupportsWrite[str], *, trim: bool = False, rounding_precision: int = -1, **kw) -> None: ...