Add files using upload-large-folder tool

.gitattributes

@@ -1800,3 +1800,4 @@ vllm/lib/python3.10/site-packages/cupy/_core/_fusion_trace.cpython-310-x86_64-li
 parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/givens_elimination.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/shapely/_geos.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/shapely/lib.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/cupyx/cudnn.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

vllm/lib/python3.10/site-packages/cupyx/cudnn.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fdc9b696bd071426ccbb30e5a2c43f03afd0c5ff54a08b8f39bd245e140a263f
+size 4677920

vllm/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py33_np18.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e064c2eecfdc58d552844467da7bd56eca596098322bfd266a7e1312abdd5735
+size 1068

vllm/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py33_np18.pkl.bz2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e86d6f6ecfe2626cf691827ac38a81d64ec3ebb527c5432eb344b8496781b45a
+size 1000

vllm/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.2_pickle_py27_np16.pkl_02.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c1cf36cb781fbcc21b953bb0a0b45df092da0eae0e765882e5963ccd70105b1
+size 120

vllm/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.2_pickle_py27_np16.pkl_04.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ecbe244294ba93e08479b16c1b9a9411e3569ff660ed0459dca1d241381df05
+size 104

vllm/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.2_pickle_py34_np19.pkl_01.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0efbd7d9ce7eec3a6e0a0db41e795e0396cca3d6b037dad6c61b464843d28809
+size 120

vllm/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.4.dev0_compressed_cache_size_pickle_py35_np19.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2361f589b31d2863627edcb96612280ae5c0a59c9496d89dab7de493670f93b
+size 802

vllm/lib/python3.10/site-packages/shapely/tests/common.py

@@ -0,0 +1,125 @@
+from contextlib import contextmanager
+
+import numpy as np
+import pytest
+
+import shapely
+
+shapely20_todo = pytest.mark.xfail(
+    strict=False, reason="Not yet implemented for Shapely 2.0"
+)
+
+point_polygon_testdata = (
+    shapely.points(np.arange(6), np.arange(6)),
+    shapely.box(2, 2, 4, 4),
+)
+point = shapely.Point(2, 3)
+line_string = shapely.LineString([(0, 0), (1, 0), (1, 1)])
+linear_ring = shapely.LinearRing([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)])
+polygon = shapely.Polygon([(0, 0), (2, 0), (2, 2), (0, 2), (0, 0)])
+multi_point = shapely.MultiPoint([(0, 0), (1, 2)])
+multi_line_string = shapely.MultiLineString([[(0, 0), (1, 2)]])
+multi_polygon = shapely.multipolygons(
+    [
+        [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)],
+        [(2.1, 2.1), (2.2, 2.1), (2.2, 2.2), (2.1, 2.2), (2.1, 2.1)],
+    ]
+)
+geometry_collection = shapely.GeometryCollection(
+    [shapely.Point(51, -1), shapely.LineString([(52, -1), (49, 2)])]
+)
+point_z = shapely.Point(2, 3, 4)
+line_string_z = shapely.LineString([(0, 0, 4), (1, 0, 4), (1, 1, 4)])
+polygon_z = shapely.Polygon([(0, 0, 4), (2, 0, 4), (2, 2, 4), (0, 2, 4), (0, 0, 4)])
+geometry_collection_z = shapely.GeometryCollection([point_z, line_string_z])
+polygon_with_hole = shapely.Polygon(
+    [(0, 0), (0, 10), (10, 10), (10, 0), (0, 0)],
+    holes=[[(2, 2), (2, 4), (4, 4), (4, 2), (2, 2)]],
+)
+empty_point = shapely.from_wkt("POINT EMPTY")
+empty_point_z = shapely.from_wkt("POINT Z EMPTY")
+empty_line_string = shapely.from_wkt("LINESTRING EMPTY")
+empty_line_string_z = shapely.from_wkt("LINESTRING Z EMPTY")
+empty_polygon = shapely.from_wkt("POLYGON EMPTY")
+empty = shapely.from_wkt("GEOMETRYCOLLECTION EMPTY")
+multi_point_z = shapely.MultiPoint([(0, 0, 4), (1, 2, 4)])
+multi_line_string_z = shapely.MultiLineString([[(0, 0, 4), (1, 2, 4)]])
+multi_polygon_z = shapely.multipolygons(
+    [
+        [(0, 0, 4), (1, 0, 4), (1, 1, 4), (0, 1, 4), (0, 0, 4)],
+        [(2.1, 2.1, 4), (2.2, 2.1, 4), (2.2, 2.2, 4), (2.1, 2.2, 4), (2.1, 2.1, 4)],
+    ]
+)
+polygon_with_hole_z = shapely.Polygon(
+    [(0, 0, 4), (0, 10, 4), (10, 10, 4), (10, 0, 4), (0, 0, 4)],
+    holes=[[(2, 2, 4), (2, 4, 4), (4, 4, 4), (4, 2, 4), (2, 2, 4)]],
+)
+
+all_types = (
+    point,
+    line_string,
+    linear_ring,
+    polygon,
+    multi_point,
+    multi_line_string,
+    multi_polygon,
+    geometry_collection,
+    empty,
+)
+
+all_types_z = (
+    point_z,
+    line_string_z,
+    polygon_z,
+    multi_point_z,
+    multi_line_string_z,
+    multi_polygon_z,
+    polygon_with_hole_z,
+    geometry_collection_z,
+    empty_point_z,
+    empty_line_string_z,
+)
+
+
+@contextmanager
+def ignore_invalid(condition=True):
+    if condition:
+        with np.errstate(invalid="ignore"):
+            yield
+    else:
+        yield
+
+
+with ignore_invalid():
+    line_string_nan = shapely.LineString([(np.nan, np.nan), (np.nan, np.nan)])
+
+
+class ArrayLike:
+    """
+    Simple numpy Array like class that implements the
+    ufunc protocol.
+    """
+
+    def __init__(self, array):
+        self._array = np.asarray(array)
+
+    def __len__(self):
+        return len(self._array)
+
+    def __getitem(self, key):
+        return self._array[key]
+
+    def __iter__(self):
+        return self._array.__iter__()
+
+    def __array__(self):
+        return np.asarray(self._array)
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        if method == "__call__":
+            inputs = [
+                arg._array if isinstance(arg, self.__class__) else arg for arg in inputs
+            ]
+            return self.__class__(ufunc(*inputs, **kwargs))
+        else:
+            return NotImplemented

vllm/lib/python3.10/site-packages/shapely/tests/geometry/test_collection.py

@@ -0,0 +1,82 @@
+import numpy as np
+import pytest
+
+from shapely import GeometryCollection, LineString, Point, wkt
+from shapely.geometry import shape
+
+
+@pytest.fixture()
+def geometrycollection_geojson():
+    return {
+        "type": "GeometryCollection",
+        "geometries": [
+            {"type": "Point", "coordinates": (0, 3, 0)},
+            {"type": "LineString", "coordinates": ((2, 0), (1, 0))},
+        ],
+    }
+
+
+@pytest.mark.parametrize(
+    "geom",
+    [
+        GeometryCollection(),
+        shape({"type": "GeometryCollection", "geometries": []}),
+        wkt.loads("GEOMETRYCOLLECTION EMPTY"),
+    ],
+)
+def test_empty(geom):
+    assert geom.geom_type == "GeometryCollection"
+    assert geom.is_empty
+    assert len(geom.geoms) == 0
+    assert list(geom.geoms) == []
+
+
+def test_empty_subgeoms():
+    geom = GeometryCollection([Point(), LineString()])
+    assert geom.geom_type == "GeometryCollection"
+    assert geom.is_empty
+    assert len(geom.geoms) == 2
+    assert list(geom.geoms) == [Point(), LineString()]
+
+
+def test_child_with_deleted_parent():
+    # test that we can remove a collection while keeping
+    # children around
+    a = LineString([(0, 0), (1, 1), (1, 2), (2, 2)])
+    b = LineString([(0, 0), (1, 1), (2, 1), (2, 2)])
+    collection = a.intersection(b)
+
+    child = collection.geoms[0]
+    # delete parent of child
+    del collection
+
+    # access geometry, this should not seg fault as 1.2.15 did
+    assert child.wkt is not None
+
+
+def test_from_geojson(geometrycollection_geojson):
+    geom = shape(geometrycollection_geojson)
+    assert geom.geom_type == "GeometryCollection"
+    assert len(geom.geoms) == 2
+
+    geom_types = [g.geom_type for g in geom.geoms]
+    assert "Point" in geom_types
+    assert "LineString" in geom_types
+
+
+def test_geointerface(geometrycollection_geojson):
+    geom = shape(geometrycollection_geojson)
+    assert geom.__geo_interface__ == geometrycollection_geojson
+
+
+def test_len_raises(geometrycollection_geojson):
+    geom = shape(geometrycollection_geojson)
+    with pytest.raises(TypeError):
+        len(geom)
+
+
+def test_numpy_object_array():
+    geom = GeometryCollection([LineString([(0, 0), (1, 1)])])
+    ar = np.empty(1, object)
+    ar[:] = [geom]
+    assert ar[0] == geom

vllm/lib/python3.10/site-packages/shapely/tests/geometry/test_coords.py

@@ -0,0 +1,102 @@
+import numpy as np
+import pytest
+
+from shapely import LineString
+from shapely.tests.common import line_string, line_string_z, point, point_z
+
+
+class TestCoords:
+    """
+    Shapely assumes contiguous C-order float64 data for internal ops.
+    Data should be converted to contiguous float64 if numpy exists.
+    c9a0707 broke this a little bit.
+    """
+
+    def test_data_promotion(self):
+        coords = np.array([[12, 34], [56, 78]], dtype=np.float32)
+        processed_coords = np.array(LineString(coords).coords)
+
+        assert coords.tolist() == processed_coords.tolist()
+
+    def test_data_destriding(self):
+        coords = np.array([[12, 34], [56, 78]], dtype=np.float32)
+
+        # Easy way to introduce striding: reverse list order
+        processed_coords = np.array(LineString(coords[::-1]).coords)
+
+        assert coords[::-1].tolist() == processed_coords.tolist()
+
+
+class TestCoordsGetItem:
+    def test_index_2d_coords(self):
+        c = [(float(x), float(-x)) for x in range(4)]
+        g = LineString(c)
+        for i in range(-4, 4):
+            assert g.coords[i] == c[i]
+        with pytest.raises(IndexError):
+            g.coords[4]
+        with pytest.raises(IndexError):
+            g.coords[-5]
+
+    def test_index_3d_coords(self):
+        c = [(float(x), float(-x), float(x * 2)) for x in range(4)]
+        g = LineString(c)
+        for i in range(-4, 4):
+            assert g.coords[i] == c[i]
+        with pytest.raises(IndexError):
+            g.coords[4]
+        with pytest.raises(IndexError):
+            g.coords[-5]
+
+    def test_index_coords_misc(self):
+        g = LineString()  # empty
+        with pytest.raises(IndexError):
+            g.coords[0]
+        with pytest.raises(TypeError):
+            g.coords[0.0]
+
+    def test_slice_2d_coords(self):
+        c = [(float(x), float(-x)) for x in range(4)]
+        g = LineString(c)
+        assert g.coords[1:] == c[1:]
+        assert g.coords[:-1] == c[:-1]
+        assert g.coords[::-1] == c[::-1]
+        assert g.coords[::2] == c[::2]
+        assert g.coords[:4] == c[:4]
+        assert g.coords[4:] == c[4:] == []
+
+    def test_slice_3d_coords(self):
+        c = [(float(x), float(-x), float(x * 2)) for x in range(4)]
+        g = LineString(c)
+        assert g.coords[1:] == c[1:]
+        assert g.coords[:-1] == c[:-1]
+        assert g.coords[::-1] == c[::-1]
+        assert g.coords[::2] == c[::2]
+        assert g.coords[:4] == c[:4]
+        assert g.coords[4:] == c[4:] == []
+
+
+class TestXY:
+    """New geometry/coordseq method 'xy' makes numpy interop easier"""
+
+    def test_arrays(self):
+        x, y = LineString([(0, 0), (1, 1)]).xy
+        assert len(x) == 2
+        assert list(x) == [0.0, 1.0]
+        assert len(y) == 2
+        assert list(y) == [0.0, 1.0]
+
+
+@pytest.mark.parametrize("geom", [point, point_z, line_string, line_string_z])
+def test_coords_array_copy(geom):
+    """Test CoordinateSequence.__array__ method."""
+    coord_seq = geom.coords
+    assert np.array(coord_seq) is not np.array(coord_seq)
+    assert np.array(coord_seq, copy=True) is not np.array(coord_seq, copy=True)
+
+    # Behaviour of copy=False is different between NumPy 1.x and 2.x
+    if int(np.version.short_version.split(".", 1)[0]) >= 2:
+        with pytest.raises(ValueError, match="A copy is always created"):
+            np.array(coord_seq, copy=False)
+    else:
+        assert np.array(coord_seq, copy=False) is np.array(coord_seq, copy=False)

vllm/lib/python3.10/site-packages/shapely/tests/geometry/test_decimal.py

@@ -0,0 +1,117 @@
+from decimal import Decimal
+
+import pytest
+
+from shapely import (
+    GeometryCollection,
+    LinearRing,
+    LineString,
+    MultiLineString,
+    MultiPoint,
+    MultiPolygon,
+    Point,
+    Polygon,
+)
+
+items2d = [
+    [(0.0, 0.0), (70.0, 120.0), (140.0, 0.0), (0.0, 0.0)],
+    [(60.0, 80.0), (80.0, 80.0), (70.0, 60.0), (60.0, 80.0)],
+]
+
+items2d_mixed = [
+    [
+        (Decimal(0.0), Decimal(0.0)),
+        (Decimal(70.0), 120.0),
+        (140.0, Decimal(0.0)),
+        (0.0, 0.0),
+    ],
+    [
+        (Decimal(60.0), Decimal(80.0)),
+        (Decimal(80.0), 80.0),
+        (70.0, Decimal(60.0)),
+        (60.0, 80.0),
+    ],
+]
+
+items2d_decimal = [
+    [
+        (Decimal(0.0), Decimal(0.0)),
+        (Decimal(70.0), Decimal(120.0)),
+        (Decimal(140.0), Decimal(0.0)),
+        (Decimal(0.0), Decimal(0.0)),
+    ],
+    [
+        (Decimal(60.0), Decimal(80.0)),
+        (Decimal(80.0), Decimal(80.0)),
+        (Decimal(70.0), Decimal(60.0)),
+        (Decimal(60.0), Decimal(80.0)),
+    ],
+]
+
+items3d = [
+    [(0.0, 0.0, 1), (70.0, 120.0, 2), (140.0, 0.0, 3), (0.0, 0.0, 1)],
+    [(60.0, 80.0, 1), (80.0, 80.0, 2), (70.0, 60.0, 3), (60.0, 80.0, 1)],
+]
+
+items3d_mixed = [
+    [
+        (Decimal(0.0), Decimal(0.0), Decimal(1)),
+        (Decimal(70.0), 120.0, Decimal(2)),
+        (140.0, Decimal(0.0), 3),
+        (0.0, 0.0, 1),
+    ],
+    [
+        (Decimal(60.0), Decimal(80.0), Decimal(1)),
+        (Decimal(80.0), 80.0, 2),
+        (70.0, Decimal(60.0), Decimal(3)),
+        (60.0, 80.0, 1),
+    ],
+]
+
+items3d_decimal = [
+    [
+        (Decimal(0.0), Decimal(0.0), Decimal(1)),
+        (Decimal(70.0), Decimal(120.0), Decimal(2)),
+        (Decimal(140.0), Decimal(0.0), Decimal(3)),
+        (Decimal(0.0), Decimal(0.0), Decimal(1)),
+    ],
+    [
+        (Decimal(60.0), Decimal(80.0), Decimal(1)),
+        (Decimal(80.0), Decimal(80.0), Decimal(2)),
+        (Decimal(70.0), Decimal(60.0), Decimal(3)),
+        (Decimal(60.0), Decimal(80.0), Decimal(1)),
+    ],
+]
+
+all_geoms = [
+    [
+        Point(items[0][0]),
+        Point(*items[0][0]),
+        MultiPoint(items[0]),
+        LinearRing(items[0]),
+        LineString(items[0]),
+        MultiLineString(items),
+        Polygon(items[0]),
+        MultiPolygon(
+            [
+                Polygon(items[1]),
+                Polygon(items[0], holes=items[1:]),
+            ]
+        ),
+        GeometryCollection([Point(items[0][0]), Polygon(items[0])]),
+    ]
+    for items in [
+        items2d,
+        items2d_mixed,
+        items2d_decimal,
+        items3d,
+        items3d_mixed,
+        items3d_decimal,
+    ]
+]
+
+
+@pytest.mark.parametrize("geoms", list(zip(*all_geoms)))
+def test_decimal(geoms):
+    assert geoms[0] == geoms[1] == geoms[2]
+    assert geoms[3] == geoms[4] == geoms[5]

vllm/lib/python3.10/site-packages/shapely/tests/geometry/test_emptiness.py

@@ -0,0 +1,98 @@
+import math
+
+import numpy as np
+import pytest
+
+from shapely import (
+    GeometryCollection,
+    LinearRing,
+    LineString,
+    MultiLineString,
+    MultiPoint,
+    MultiPolygon,
+    Point,
+    Polygon,
+)
+from shapely.geometry import mapping, shape
+from shapely.geometry.base import BaseGeometry, EmptyGeometry
+
+
+def empty_generator():
+    return iter([])
+
+
+class TestEmptiness:
+    def test_empty_class(self):
+        with pytest.warns(FutureWarning):
+            g = EmptyGeometry()
+        assert g.is_empty
+
+    def test_empty_base(self):
+        with pytest.warns(FutureWarning):
+            g = BaseGeometry()
+        assert g.is_empty
+
+    def test_empty_point(self):
+        assert Point().is_empty
+
+    def test_empty_multipoint(self):
+        assert MultiPoint().is_empty
+
+    def test_empty_geometry_collection(self):
+        assert GeometryCollection().is_empty
+
+    def test_empty_linestring(self):
+        assert LineString().is_empty
+        assert LineString(None).is_empty
+        assert LineString([]).is_empty
+        assert LineString(empty_generator()).is_empty
+
+    def test_empty_multilinestring(self):
+        assert MultiLineString([]).is_empty
+
+    def test_empty_polygon(self):
+        assert Polygon().is_empty
+        assert Polygon(None).is_empty
+        assert Polygon([]).is_empty
+        assert Polygon(empty_generator()).is_empty
+
+    def test_empty_multipolygon(self):
+        assert MultiPolygon([]).is_empty
+
+    def test_empty_linear_ring(self):
+        assert LinearRing().is_empty
+        assert LinearRing(None).is_empty
+        assert LinearRing([]).is_empty
+        assert LinearRing(empty_generator()).is_empty
+
+
+def test_numpy_object_array():
+    geoms = [Point(), GeometryCollection()]
+    arr = np.empty(2, object)
+    arr[:] = geoms
+
+
+def test_shape_empty():
+    empty_mp = MultiPolygon()
+    empty_json = mapping(empty_mp)
+    empty_shape = shape(empty_json)
+    assert empty_shape.is_empty
+
+
+@pytest.mark.parametrize(
+    "geom",
+    [
+        Point(),
+        LineString(),
+        Polygon(),
+        MultiPoint(),
+        MultiLineString(),
+        MultiPolygon(),
+        GeometryCollection(),
+        LinearRing(),
+    ],
+)
+def test_empty_geometry_bounds(geom):
+    """The bounds of an empty geometry is a tuple of NaNs"""
+    assert len(geom.bounds) == 4
+    assert all(math.isnan(v) for v in geom.bounds)

vllm/lib/python3.10/site-packages/shapely/tests/geometry/test_equality.py

@@ -0,0 +1,237 @@
+import numpy as np
+import pytest
+
+import shapely
+from shapely import LinearRing, LineString, MultiLineString, Point, Polygon
+from shapely.tests.common import all_types, all_types_z, ignore_invalid
+
+
+@pytest.mark.parametrize("geom", all_types + all_types_z)
+def test_equality(geom):
+    assert geom == geom
+    transformed = shapely.transform(geom, lambda x: x, include_z=True)
+    assert geom == transformed
+    assert not (geom != transformed)
+
+
+@pytest.mark.parametrize(
+    "left, right",
+    [
+        # (slightly) different coordinate values
+        (LineString([(0, 0), (1, 1)]), LineString([(0, 0), (1, 2)])),
+        (LineString([(0, 0), (1, 1)]), LineString([(0, 0), (1, 1 + 1e-12)])),
+        # different coordinate order
+        (LineString([(0, 0), (1, 1)]), LineString([(1, 1), (0, 0)])),
+        # different number of coordinates (but spatially equal)
+        (LineString([(0, 0), (1, 1)]), LineString([(0, 0), (1, 1), (1, 1)])),
+        (LineString([(0, 0), (1, 1)]), LineString([(0, 0), (0.5, 0.5), (1, 1)])),
+        # different order of sub-geometries
+        (
+            MultiLineString([[(1, 1), (2, 2)], [(2, 2), (3, 3)]]),
+            MultiLineString([[(2, 2), (3, 3)], [(1, 1), (2, 2)]]),
+        ),
+    ],
+)
+def test_equality_false(left, right):
+    assert left != right
+
+
+with ignore_invalid():
+    cases1 = [
+        (LineString([(0, 1), (2, np.nan)]), LineString([(0, 1), (2, np.nan)])),
+        (
+            LineString([(0, 1), (np.nan, np.nan)]),
+            LineString([(0, 1), (np.nan, np.nan)]),
+        ),
+        (LineString([(np.nan, 1), (2, 3)]), LineString([(np.nan, 1), (2, 3)])),
+        (LineString([(0, np.nan), (2, 3)]), LineString([(0, np.nan), (2, 3)])),
+        (
+            LineString([(np.nan, np.nan), (np.nan, np.nan)]),
+            LineString([(np.nan, np.nan), (np.nan, np.nan)]),
+        ),
+        # NaN as explicit Z coordinate
+        # TODO: if first z is NaN -> considered as 2D -> tested below explicitly
+        # (
+        #     LineString([(0, 1, np.nan), (2, 3, np.nan)]),
+        #     LineString([(0, 1, np.nan), (2, 3, np.nan)]),
+        # ),
+        (
+            LineString([(0, 1, 2), (2, 3, np.nan)]),
+            LineString([(0, 1, 2), (2, 3, np.nan)]),
+        ),
+        # (
+        #     LineString([(0, 1, np.nan), (2, 3, 4)]),
+        #     LineString([(0, 1, np.nan), (2, 3, 4)]),
+        # ),
+    ]
+
+
+@pytest.mark.parametrize("left, right", cases1)
+def test_equality_with_nan(left, right):
+    # TODO currently those evaluate as not equal, but we are considering to change this
+    # assert left == right
+    assert not (left == right)
+    # assert not (left != right)
+    assert left != right
+
+
+with ignore_invalid():
+    cases2 = [
+        (
+            LineString([(0, 1, np.nan), (2, 3, np.nan)]),
+            LineString([(0, 1, np.nan), (2, 3, np.nan)]),
+        ),
+        (
+            LineString([(0, 1, np.nan), (2, 3, 4)]),
+            LineString([(0, 1, np.nan), (2, 3, 4)]),
+        ),
+    ]
+
+
+@pytest.mark.parametrize("left, right", cases2)
+def test_equality_with_nan_z(left, right):
+    # TODO: those are currently considered equal because z dimension is ignored
+    if shapely.geos_version < (3, 12, 0):
+        assert left == right
+        assert not (left != right)
+    else:
+        # on GEOS main z dimension is not ignored -> NaNs cause inequality
+        assert left != right
+
+
+with ignore_invalid():
+    cases3 = [
+        (LineString([(0, np.nan), (2, 3)]), LineString([(0, 1), (2, 3)])),
+        (LineString([(0, 1), (2, np.nan)]), LineString([(0, 1), (2, 3)])),
+        (LineString([(0, 1, np.nan), (2, 3, 4)]), LineString([(0, 1, 2), (2, 3, 4)])),
+        (LineString([(0, 1, 2), (2, 3, np.nan)]), LineString([(0, 1, 2), (2, 3, 4)])),
+    ]
+
+
+@pytest.mark.parametrize("left, right", cases3)
+def test_equality_with_nan_false(left, right):
+    assert left != right
+
+
+def test_equality_with_nan_z_false():
+    with ignore_invalid():
+        left = LineString([(0, 1, np.nan), (2, 3, np.nan)])
+        right = LineString([(0, 1, np.nan), (2, 3, 4)])
+
+    if shapely.geos_version < (3, 10, 0):
+        # GEOS <= 3.9 fill the NaN with 0, so the z dimension is different
+        # assert left != right
+        # however, has_z still returns False, so z dimension is ignored in .coords
+        assert left == right
+    elif shapely.geos_version < (3, 12, 0):
+        # GEOS 3.10-3.11 ignore NaN for Z also when explicitly created with 3D
+        # and so the geometries are considered as 2D (and thus z dimension is ignored)
+        assert left == right
+    else:
+        assert left != right
+
+
+def test_equality_z():
+    # different dimensionality
+    geom1 = Point(0, 1)
+    geom2 = Point(0, 1, 0)
+    assert geom1 != geom2
+
+    # different dimensionality with NaN z
+    geom2 = Point(0, 1, np.nan)
+    if shapely.geos_version < (3, 10, 0):
+        # GEOS < 3.8 fill the NaN with 0, so the z dimension is different
+        # assert geom1 != geom2
+        # however, has_z still returns False, so z dimension is ignored in .coords
+        assert geom1 == geom2
+    elif shapely.geos_version < (3, 12, 0):
+        # GEOS 3.10-3.11 ignore NaN for Z also when explicitly created with 3D
+        # and so the geometries are considered as 2D (and thus z dimension is ignored)
+        assert geom1 == geom2
+    else:
+        assert geom1 != geom2
+
+
+def test_equality_exact_type():
+    # geometries with different type but same coord seq are not equal
+    geom1 = LineString([(0, 0), (1, 1), (0, 1), (0, 0)])
+    geom2 = LinearRing([(0, 0), (1, 1), (0, 1), (0, 0)])
+    geom3 = Polygon([(0, 0), (1, 1), (0, 1), (0, 0)])
+    assert geom1 != geom2
+    assert geom1 != geom3
+    assert geom2 != geom3
+
+    # empty with different type
+    geom1 = shapely.from_wkt("POINT EMPTY")
+    geom2 = shapely.from_wkt("LINESTRING EMPTY")
+    assert geom1 != geom2
+
+
+def test_equality_polygon():
+    # different exterior rings
+    geom1 = shapely.from_wkt("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")
+    geom2 = shapely.from_wkt("POLYGON ((0 0, 10 0, 10 10, 0 15, 0 0))")
+    assert geom1 != geom2
+
+    # different number of holes
+    geom1 = shapely.from_wkt(
+        "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 1))"
+    )
+    geom2 = shapely.from_wkt(
+        "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 1), (3 3, 4 3, 4 4, 3 3))"
+    )
+    assert geom1 != geom2
+
+    # different order of holes
+    geom1 = shapely.from_wkt(
+        "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (3 3, 4 3, 4 4, 3 3), (1 1, 2 1, 2 2, 1 1))"
+    )
+    geom2 = shapely.from_wkt(
+        "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 1), (3 3, 4 3, 4 4, 3 3))"
+    )
+    assert geom1 != geom2
+
+
+@pytest.mark.parametrize("geom", all_types)
+def test_comparison_notimplemented(geom):
+    # comparing to a non-geometry class should return NotImplemented in __eq__
+    # to ensure proper delegation to other (eg to ensure comparison of scalar
+    # with array works)
+    # https://github.com/shapely/shapely/issues/1056
+    assert geom.__eq__(1) is NotImplemented
+
+    # with array
+    arr = np.array([geom, geom], dtype=object)
+
+    result = arr == geom
+    assert isinstance(result, np.ndarray)
+    assert result.all()
+
+    result = geom == arr
+    assert isinstance(result, np.ndarray)
+    assert result.all()
+
+    result = arr != geom
+    assert isinstance(result, np.ndarray)
+    assert not result.any()
+
+    result = geom != arr
+    assert isinstance(result, np.ndarray)
+    assert not result.any()
+
+
+def test_comparison_not_supported():
+    geom1 = Point(1, 1)
+    geom2 = Point(2, 2)
+
+    with pytest.raises(TypeError, match="not supported between instances"):
+        geom1 > geom2
+
+    with pytest.raises(TypeError, match="not supported between instances"):
+        geom1 < geom2
+
+    with pytest.raises(TypeError, match="not supported between instances"):
+        geom1 >= geom2
+
+    with pytest.raises(TypeError, match="not supported between instances"):
+        geom1 <= geom2

vllm/lib/python3.10/site-packages/shapely/tests/geometry/test_geometry_base.py

@@ -0,0 +1,281 @@
+import platform
+import weakref
+
+import numpy as np
+import pytest
+
+import shapely
+from shapely import (
+    GeometryCollection,
+    LinearRing,
+    LineString,
+    MultiLineString,
+    MultiPoint,
+    MultiPolygon,
+    Point,
+    Polygon,
+)
+from shapely.errors import ShapelyDeprecationWarning
+from shapely.testing import assert_geometries_equal
+
+
+def test_polygon():
+    assert bool(Polygon()) is False
+
+
+def test_linestring():
+    assert bool(LineString()) is False
+
+
+def test_point():
+    assert bool(Point()) is False
+
+
+def test_geometry_collection():
+    assert bool(GeometryCollection()) is False
+
+
+geometries_all_types = [
+    Point(1, 1),
+    LinearRing([(0, 0), (1, 1), (0, 1), (0, 0)]),
+    LineString([(0, 0), (1, 1), (0, 1), (0, 0)]),
+    Polygon([(0, 0), (1, 1), (0, 1), (0, 0)]),
+    MultiPoint([(1, 1)]),
+    MultiLineString([[(0, 0), (1, 1), (0, 1), (0, 0)]]),
+    MultiPolygon([Polygon([(0, 0), (1, 1), (0, 1), (0, 0)])]),
+    GeometryCollection([Point(1, 1)]),
+]
+
+
+@pytest.mark.skipif(
+    platform.python_implementation() == "PyPy",
+    reason="Setting custom attributes doesn't fail on PyPy",
+)
+@pytest.mark.parametrize("geom", geometries_all_types)
+def test_setattr_disallowed(geom):
+    with pytest.raises(AttributeError):
+        geom.name = "test"
+
+
+@pytest.mark.parametrize("geom", geometries_all_types)
+def test_weakrefable(geom):
+    _ = weakref.ref(geom)
+
+
+def test_base_class_not_callable():
+    with pytest.raises(TypeError):
+        shapely.Geometry("POINT (1 1)")
+
+
+def test_GeometryType_deprecated():
+    geom = Point(1, 1)
+
+    with pytest.warns(ShapelyDeprecationWarning):
+        geom_type = geom.geometryType()
+
+    assert geom_type == geom.geom_type
+
+
+def test_type_deprecated():
+    geom = Point(1, 1)
+
+    with pytest.warns(ShapelyDeprecationWarning):
+        geom_type = geom.type
+
+    assert geom_type == geom.geom_type
+
+
+@pytest.mark.skipif(shapely.geos_version < (3, 10, 0), reason="GEOS < 3.10")
+def test_segmentize():
+    line = LineString([(0, 0), (0, 10)])
+    result = line.segmentize(max_segment_length=5)
+    assert result.equals(LineString([(0, 0), (0, 5), (0, 10)]))
+
+
+@pytest.mark.skipif(shapely.geos_version < (3, 7, 0), reason="GEOS < 3.7")
+def test_reverse():
+    coords = [(0, 0), (1, 2)]
+    line = LineString(coords)
+    result = line.reverse()
+    assert result.coords[:] == coords[::-1]
+
+
+@pytest.mark.skipif(shapely.geos_version < (3, 9, 0), reason="GEOS < 3.9")
+@pytest.mark.parametrize(
+    "op", ["union", "intersection", "difference", "symmetric_difference"]
+)
+@pytest.mark.parametrize("grid_size", [0, 1, 2])
+def test_binary_op_grid_size(op, grid_size):
+    geom1 = shapely.box(0, 0, 2.5, 2.5)
+    geom2 = shapely.box(2, 2, 3, 3)
+
+    result = getattr(geom1, op)(geom2, grid_size=grid_size)
+    expected = getattr(shapely, op)(geom1, geom2, grid_size=grid_size)
+    assert result == expected
+
+
+@pytest.mark.skipif(shapely.geos_version < (3, 10, 0), reason="GEOS < 3.10")
+def test_dwithin():
+    point = Point(1, 1)
+    line = LineString([(0, 0), (0, 10)])
+    assert point.dwithin(line, 0.5) is False
+    assert point.dwithin(line, 1.5) is True
+
+
+def test_contains_properly():
+    polygon = Polygon([(0, 0), (10, 10), (10, -10)])
+    line = LineString([(0, 0), (10, 0)])
+    assert polygon.contains_properly(line) is False
+    assert polygon.contains(line) is True
+
+
+@pytest.mark.parametrize(
+    "op", ["convex_hull", "envelope", "oriented_envelope", "minimum_rotated_rectangle"]
+)
+def test_constructive_properties(op):
+    geom = LineString([(0, 0), (0, 10), (10, 10)])
+    result = getattr(geom, op)
+    expected = getattr(shapely, op)(geom)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "op",
+    [
+        "crosses",
+        "contains",
+        "contains_properly",
+        "covered_by",
+        "covers",
+        "disjoint",
+        "equals",
+        "intersects",
+        "overlaps",
+        "touches",
+        "within",
+    ],
+)
+def test_array_argument_binary_predicates(op):
+    polygon = Polygon([(0, 0), (0, 1), (1, 1), (1, 0), (0, 0)])
+    points = shapely.points([(0, 0), (0.5, 0.5), (1, 1)])
+
+    result = getattr(polygon, op)(points)
+    assert isinstance(result, np.ndarray)
+    expected = np.array([getattr(polygon, op)(p) for p in points], dtype=bool)
+    np.testing.assert_array_equal(result, expected)
+
+    # check scalar
+    result = getattr(polygon, op)(points[0])
+    assert type(result) is bool
+
+
+@pytest.mark.parametrize(
+    "op, kwargs",
+    [
+        pytest.param(
+            "dwithin",
+            dict(distance=0.5),
+            marks=pytest.mark.skipif(
+                shapely.geos_version < (3, 10, 0), reason="GEOS < 3.10"
+            ),
+        ),
+        ("equals_exact", dict(tolerance=0.01)),
+        ("relate_pattern", dict(pattern="T*F**F***")),
+    ],
+)
+def test_array_argument_binary_predicates2(op, kwargs):
+    polygon = Polygon([(0, 0), (0, 1), (1, 1), (1, 0), (0, 0)])
+    points = shapely.points([(0, 0), (0.5, 0.5), (1, 1)])
+
+    result = getattr(polygon, op)(points, **kwargs)
+    assert isinstance(result, np.ndarray)
+    expected = np.array([getattr(polygon, op)(p, **kwargs) for p in points], dtype=bool)
+    np.testing.assert_array_equal(result, expected)
+
+    # check scalar
+    result = getattr(polygon, op)(points[0], **kwargs)
+    assert type(result) is bool
+
+
+@pytest.mark.parametrize(
+    "op",
+    [
+        "difference",
+        "intersection",
+        "symmetric_difference",
+        "union",
+    ],
+)
+def test_array_argument_binary_geo(op):
+    box = Polygon([(0, 0), (0, 1), (1, 1), (1, 0), (0, 0)])
+    polygons = shapely.buffer(shapely.points([(0, 0), (0.5, 0.5), (1, 1)]), 0.5)
+
+    result = getattr(box, op)(polygons)
+    assert isinstance(result, np.ndarray)
+    expected = np.array([getattr(box, op)(g) for g in polygons], dtype=object)
+    assert_geometries_equal(result, expected)
+
+    # check scalar
+    result = getattr(box, op)(polygons[0])
+    assert isinstance(result, (Polygon, MultiPolygon))
+
+
+@pytest.mark.parametrize("op", ["distance", "hausdorff_distance"])
+def test_array_argument_float(op):
+    polygon = Polygon([(0, 0), (0, 1), (1, 1), (1, 0), (0, 0)])
+    points = shapely.points([(0, 0), (0.5, 0.5), (1, 1)])
+
+    result = getattr(polygon, op)(points)
+    assert isinstance(result, np.ndarray)
+    expected = np.array([getattr(polygon, op)(p) for p in points], dtype="float64")
+    np.testing.assert_array_equal(result, expected)
+
+    # check scalar
+    result = getattr(polygon, op)(points[0])
+    assert type(result) is float
+
+
+@pytest.mark.parametrize("op", ["line_interpolate_point", "interpolate"])
+def test_array_argument_linear_point(op):
+    line = LineString([(0, 0), (0, 1), (1, 1)])
+    distances = np.array([0, 0.5, 1])
+
+    result = getattr(line, op)(distances)
+    assert isinstance(result, np.ndarray)
+    expected = np.array(
+        [line.line_interpolate_point(d) for d in distances], dtype=object
+    )
+    assert_geometries_equal(result, expected)
+
+    # check scalar
+    result = getattr(line, op)(distances[0])
+    assert isinstance(result, Point)
+
+
+@pytest.mark.parametrize("op", ["line_locate_point", "project"])
+def test_array_argument_linear_float(op):
+    line = LineString([(0, 0), (0, 1), (1, 1)])
+    points = shapely.points([(0, 0), (0.5, 0.5), (1, 1)])
+
+    result = getattr(line, op)(points)
+    assert isinstance(result, np.ndarray)
+    expected = np.array([line.line_locate_point(p) for p in points], dtype="float64")
+    np.testing.assert_array_equal(result, expected)
+
+    # check scalar
+    result = getattr(line, op)(points[0])
+    assert type(result) is float
+
+
+def test_array_argument_buffer():
+    point = Point(1, 1)
+    distances = np.array([0, 0.5, 1])
+
+    result = point.buffer(distances)
+    assert isinstance(result, np.ndarray)
+    expected = np.array([point.buffer(d) for d in distances], dtype=object)
+    assert_geometries_equal(result, expected)
+
+    # check scalar
+    result = point.buffer(distances[0])
+    assert isinstance(result, Polygon)