Add shapely stubs

pyrightconfig.stricter.json

@@ -92,6 +92,7 @@
         "stubs/requests-oauthlib",
         "stubs/seaborn",
         "stubs/setuptools/setuptools",
+        "stubs/shapely",
         "stubs/tensorflow",
         "stubs/tqdm",
         "stubs/ttkthemes",

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,32 @@
+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__: 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,61 @@
+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")
+_T_co = TypeVar("_T_co", covariant=True)
+_T_contra = TypeVar("_T_contra", contravariant=True)
+_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]: ...
+
+@type_check_only
+class SupportsRead(Protocol[_T_co]):
+    def read(self) -> _T_co: ...
+
+@type_check_only
+class SupportsWrite(Protocol[_T_contra]):
+    def write(self, s: _T_contra, /) -> object: ...

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