basedpyright 1.12.4 → 1.12.5

package/dist/typeshed-fallback/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

package/dist/typeshed-fallback/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: ...

package/dist/typeshed-fallback/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: ...

package/dist/typeshed-fallback/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: ...

package/dist/typeshed-fallback/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]

package/dist/typeshed-fallback/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: ...

package/dist/typeshed-fallback/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_]: ...

package/dist/typeshed-fallback/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: ...

package/dist/typeshed-fallback/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]: ...

package/dist/typeshed-fallback/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: ...