basedpyright 1.12.4 → 1.12.5

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

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

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

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

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

package/dist/typeshed-fallback/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 = 1  # noqa: Y052
+    within = 2  # noqa: Y052
+    contains = 3  # noqa: Y052
+    overlaps = 4  # noqa: Y052
+    crosses = 5  # noqa: Y052
+    touches = 6  # noqa: Y052
+    covers = 7  # noqa: Y052
+    covered_by = 8  # noqa: Y052
+    contains_properly = 9  # noqa: Y052
+
+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]]: ...

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

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

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

package/dist/typeshed-fallback/stubs/shapely/shapely/wkb.pyi

@@ -0,0 +1,16 @@
+from typing import Literal, overload
+
+from ._typing import SupportsRead, SupportsWrite
+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: ...

package/dist/typeshed-fallback/stubs/shapely/shapely/wkt.pyi

@@ -0,0 +1,8 @@
+from ._typing 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: ...

package/package.json

@@ -2,7 +2,7 @@
     "name": "basedpyright",
     "displayName": "basedpyright",
     "description": "a pyright fork with various type checking improvements, improved vscode support and pylance features built into the language server",
-    "version": "1.12.4",
+    "version": "1.12.5",
     "license": "MIT",
     "author": {
         "name": "detachhead"

package/dist/typeshed-fallback/stubs/setuptools/setuptools/dep_util.pyi

@@ -1 +0,0 @@
-from ._distutils._modified import newer_group as newer_group, newer_pairwise_group as newer_pairwise_group

package/dist/typeshed-fallback/stubs/stripe/METADATA.toml

@@ -1,7 +0,0 @@
-version = "3.5.*"
-upstream_repository = "https://github.com/stripe/stripe-python"
-partial_stub = true
-obsolete_since = "7.1.0" # Released on 2023-10-27
-
-[tool.stubtest]
-ignore_missing_stub = true

package/dist/typeshed-fallback/stubs/stripe/stripe/__init__.pyi

@@ -1,25 +0,0 @@
-from _typeshed import Incomplete
-from typing import Any
-
-from stripe.api_resources import *
-from stripe.oauth import OAuth as OAuth
-from stripe.webhook import Webhook as Webhook, WebhookSignature as WebhookSignature
-
-api_key: str | None
-client_id: Any
-api_base: str
-connect_api_base: str
-upload_api_base: str
-api_version: Any
-verify_ssl_certs: bool
-proxy: Any
-default_http_client: Any
-app_info: Any
-enable_telemetry: bool
-max_network_retries: int
-ca_bundle_path: Any
-log: Any
-
-def set_app_info(
-    name, partner_id: Incomplete | None = None, url: Incomplete | None = None, version: Incomplete | None = None
-) -> None: ...

package/dist/typeshed-fallback/stubs/stripe/stripe/api_requestor.pyi

@@ -1,38 +0,0 @@
-from _typeshed import Incomplete
-from typing import Any
-
-from stripe import error as error, http_client as http_client, oauth_error as oauth_error, version as version
-from stripe.multipart_data_generator import MultipartDataGenerator as MultipartDataGenerator
-from stripe.stripe_response import StripeResponse as StripeResponse, StripeStreamResponse as StripeStreamResponse
-
-class APIRequestor:
-    api_base: Any
-    api_key: Any
-    api_version: Any
-    stripe_account: Any
-    def __init__(
-        self,
-        key: Incomplete | None = None,
-        client: Incomplete | None = None,
-        api_base: Incomplete | None = None,
-        api_version: Incomplete | None = None,
-        account: Incomplete | None = None,
-    ) -> None: ...
-    @classmethod
-    def format_app_info(cls, info): ...
-    def request(self, method, url, params: Incomplete | None = None, headers: Incomplete | None = None): ...
-    def request_stream(self, method, url, params: Incomplete | None = None, headers: Incomplete | None = None): ...
-    def handle_error_response(self, rbody, rcode, resp, rheaders) -> None: ...
-    def specific_api_error(self, rbody, rcode, resp, rheaders, error_data): ...
-    def specific_oauth_error(self, rbody, rcode, resp, rheaders, error_code): ...
-    def request_headers(self, api_key, method): ...
-    def request_raw(
-        self,
-        method,
-        url,
-        params: Incomplete | None = None,
-        supplied_headers: Incomplete | None = None,
-        is_streaming: bool = False,
-    ): ...
-    def interpret_response(self, rbody, rcode, rheaders): ...
-    def interpret_streaming_response(self, stream, rcode, rheaders): ...