basedpyright 1.12.4 → 1.12.5

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

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

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

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

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

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

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

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

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