types-shapely 2.0.0.20240526__tar.gz

types-shapely-2.0.0.20240526/CHANGELOG.md

@@ -0,0 +1,4 @@
+## 2.0.0.20240526 (2024-05-26)
+
+Add shapely stubs (#12033)
+

types-shapely-2.0.0.20240526/MANIFEST.in

@@ -0,0 +1 @@
+include CHANGELOG.md

types-shapely-2.0.0.20240526/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: types-shapely
+Version: 2.0.0.20240526
+Summary: Typing stubs for shapely
+Home-page: https://github.com/python/typeshed
+License: Apache-2.0 license
+Project-URL: GitHub, https://github.com/python/typeshed
+Project-URL: Changes, https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/shapely.md
+Project-URL: Issue tracker, https://github.com/python/typeshed/issues
+Project-URL: Chat, https://gitter.im/python/typing
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Stubs Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+## Typing stubs for shapely
+
+This is a [PEP 561](https://peps.python.org/pep-0561/)
+type stub package for the [`shapely`](https://github.com/shapely/shapely) package.
+It can be used by type-checking tools like
+[mypy](https://github.com/python/mypy/),
+[pyright](https://github.com/microsoft/pyright),
+[pytype](https://github.com/google/pytype/),
+PyCharm, etc. to check code that uses
+`shapely`.
+
+This version of `types-shapely` aims to provide accurate annotations
+for `shapely==2.0.*`.
+The source for this package can be found at
+https://github.com/python/typeshed/tree/main/stubs/shapely. All fixes for
+types and metadata should be contributed there.
+
+See https://github.com/python/typeshed/blob/main/README.md for more details.
+This package was generated from typeshed commit `a83f02c2d9b24831eabb1c8f07bb65576712053a` and was tested
+with mypy 1.10.0, pyright 1.1.364, and
+pytype 2024.4.11.

types-shapely-2.0.0.20240526/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

types-shapely-2.0.0.20240526/setup.py

@@ -0,0 +1,51 @@
+from setuptools import setup
+
+name = "types-shapely"
+description = "Typing stubs for shapely"
+long_description = '''
+## Typing stubs for shapely
+
+This is a [PEP 561](https://peps.python.org/pep-0561/)
+type stub package for the [`shapely`](https://github.com/shapely/shapely) package.
+It can be used by type-checking tools like
+[mypy](https://github.com/python/mypy/),
+[pyright](https://github.com/microsoft/pyright),
+[pytype](https://github.com/google/pytype/),
+PyCharm, etc. to check code that uses
+`shapely`.
+
+This version of `types-shapely` aims to provide accurate annotations
+for `shapely==2.0.*`.
+The source for this package can be found at
+https://github.com/python/typeshed/tree/main/stubs/shapely. All fixes for
+types and metadata should be contributed there.
+
+See https://github.com/python/typeshed/blob/main/README.md for more details.
+This package was generated from typeshed commit `a83f02c2d9b24831eabb1c8f07bb65576712053a` and was tested
+with mypy 1.10.0, pyright 1.1.364, and
+pytype 2024.4.11.
+'''.lstrip()
+
+setup(name=name,
+      version="2.0.0.20240526",
+      description=description,
+      long_description=long_description,
+      long_description_content_type="text/markdown",
+      url="https://github.com/python/typeshed",
+      project_urls={
+          "GitHub": "https://github.com/python/typeshed",
+          "Changes": "https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/shapely.md",
+          "Issue tracker": "https://github.com/python/typeshed/issues",
+          "Chat": "https://gitter.im/python/typing",
+      },
+      install_requires=['numpy>=1.20'],
+      packages=['shapely-stubs'],
+      package_data={'shapely-stubs': ['__init__.pyi', '_enum.pyi', '_geometry.pyi', '_ragged_array.pyi', '_typing.pyi', '_version.pyi', 'affinity.pyi', 'algorithms/__init__.pyi', 'algorithms/cga.pyi', 'algorithms/polylabel.pyi', 'constructive.pyi', 'coordinates.pyi', 'coords.pyi', 'creation.pyi', 'decorators.pyi', 'errors.pyi', 'geometry/__init__.pyi', 'geometry/base.pyi', 'geometry/collection.pyi', 'geometry/geo.pyi', 'geometry/linestring.pyi', 'geometry/multilinestring.pyi', 'geometry/multipoint.pyi', 'geometry/multipolygon.pyi', 'geometry/point.pyi', 'geometry/polygon.pyi', 'geos.pyi', 'io.pyi', 'lib.pyi', 'linear.pyi', 'measurement.pyi', 'ops.pyi', 'plotting.pyi', 'predicates.pyi', 'prepared.pyi', 'set_operations.pyi', 'speedups.pyi', 'strtree.pyi', 'testing.pyi', 'validation.pyi', 'vectorized/__init__.pyi', 'wkb.pyi', 'wkt.pyi', 'METADATA.toml', 'py.typed']},
+      license="Apache-2.0 license",
+      python_requires=">=3.8",
+      classifiers=[
+          "License :: OSI Approved :: Apache Software License",
+          "Programming Language :: Python :: 3",
+          "Typing :: Stubs Only",
+      ]
+)

types-shapely-2.0.0.20240526/shapely-stubs/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"

types-shapely-2.0.0.20240526/shapely-stubs/__init__.pyi

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

types-shapely-2.0.0.20240526/shapely-stubs/_enum.pyi

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

types-shapely-2.0.0.20240526/shapely-stubs/_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: ...

types-shapely-2.0.0.20240526/shapely-stubs/_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: ...

types-shapely-2.0.0.20240526/shapely-stubs/_typing.pyi

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

types-shapely-2.0.0.20240526/shapely-stubs/_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: ...

types-shapely-2.0.0.20240526/shapely-stubs/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: ...

types-shapely-2.0.0.20240526/shapely-stubs/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]: ...

types-shapely-2.0.0.20240526/shapely-stubs/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: ...