Add files using upload-large-folder tool

grounding-dino/.eval_venv/lib/python3.11/site-packages/shapely/tests/legacy/test_ndarrays.py

@@ -0,0 +1,42 @@
+# Tests of support for Numpy ndarrays. See
+# https://github.com/sgillies/shapely/issues/26 for discussion.
+
+import unittest
+from functools import reduce
+
+import numpy as np
+
+from shapely import geometry
+
+
+class TransposeTestCase(unittest.TestCase):
+    def test_multipoint(self):
+        arr = np.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]])
+        tarr = arr.T
+        shape = geometry.MultiPoint(tarr)
+        coords = reduce(lambda x, y: x + y, [list(g.coords) for g in shape.geoms])
+        assert coords == [(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)]
+
+    def test_linestring(self):
+        a = np.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]])
+        t = a.T
+        s = geometry.LineString(t)
+        assert list(s.coords) == [
+            (1.0, 3.0),
+            (1.0, 4.0),
+            (2.0, 4.0),
+            (2.0, 3.0),
+            (1.0, 3.0),
+        ]
+
+    def test_polygon(self):
+        a = np.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]])
+        t = a.T
+        s = geometry.Polygon(t)
+        assert list(s.exterior.coords) == [
+            (1.0, 3.0),
+            (1.0, 4.0),
+            (2.0, 4.0),
+            (2.0, 3.0),
+            (1.0, 3.0),
+        ]

grounding-dino/.eval_venv/lib/python3.11/site-packages/shapely/tests/legacy/test_nearest.py

@@ -0,0 +1,18 @@
+import unittest
+
+import pytest
+
+from shapely.geometry import Point
+from shapely.ops import nearest_points
+
+
+class Nearest(unittest.TestCase):
+    def test_nearest(self):
+        first, second = nearest_points(
+            Point(0, 0).buffer(1.0),
+            Point(3, 0).buffer(1.0),
+        )
+        assert first.x == pytest.approx(1.0)
+        assert second.x == pytest.approx(2.0)
+        assert first.y == pytest.approx(0.0)
+        assert second.y == pytest.approx(0.0)

grounding-dino/.eval_venv/lib/python3.11/site-packages/shapely/tests/legacy/test_operations.py

@@ -0,0 +1,124 @@
+import unittest
+
+import pytest
+
+import shapely
+from shapely import geos_version
+from shapely.errors import TopologicalError
+from shapely.geometry import GeometryCollection, LineString, MultiPoint, Point, Polygon
+from shapely.wkt import loads
+
+
+class OperationsTestCase(unittest.TestCase):
+    def test_operations(self):
+        point = Point(0.0, 0.0)
+
+        # General geometry
+        assert point.area == 0.0
+        assert point.length == 0.0
+        assert point.distance(Point(-1.0, -1.0)) == pytest.approx(1.4142135623730951)
+
+        # Topology operations
+
+        # Envelope
+        assert isinstance(point.envelope, Point)
+
+        # Intersection
+        assert point.intersection(Point(-1, -1)).is_empty
+
+        # Buffer
+        assert isinstance(point.buffer(10.0), Polygon)
+        assert isinstance(point.buffer(10.0, quad_segs=32), Polygon)
+
+        # Simplify
+        p = loads(
+            "POLYGON ((120 120, 140 199, 160 200, 180 199, 220 120, 122 122, 121 121, "
+            "120 120))"
+        )
+        expected = loads(
+            "POLYGON ((120 120, 140 199, 160 200, 180 199, 220 120, 120 120))"
+        )
+        s = p.simplify(10.0, preserve_topology=False)
+        assert s.equals_exact(expected, 0.001)
+
+        p = loads(
+            "POLYGON ((80 200, 240 200, 240 60, 80 60, 80 200),"
+            "(120 120, 220 120, 180 199, 160 200, 140 199, 120 120))"
+        )
+        expected = loads(
+            "POLYGON ((80 200, 240 200, 240 60, 80 60, 80 200),"
+            "(120 120, 220 120, 180 199, 160 200, 140 199, 120 120))"
+        )
+        s = p.simplify(10.0, preserve_topology=True)
+        assert s.equals_exact(expected, 0.001)
+
+        # Convex Hull
+        assert isinstance(point.convex_hull, Point)
+
+        # Differences
+        assert isinstance(point.difference(Point(-1, 1)), Point)
+
+        assert isinstance(point.symmetric_difference(Point(-1, 1)), MultiPoint)
+
+        # Boundary
+        assert isinstance(point.boundary, GeometryCollection)
+
+        # Union
+        assert isinstance(point.union(Point(-1, 1)), MultiPoint)
+
+        assert isinstance(point.representative_point(), Point)
+        assert isinstance(point.point_on_surface(), Point)
+        assert point.representative_point() == point.point_on_surface()
+
+        assert isinstance(point.centroid, Point)
+
+    def test_relate(self):
+        # Relate
+        assert Point(0, 0).relate(Point(-1, -1)) == "FF0FFF0F2"
+
+        # issue #294: should raise TopologicalError on exception
+        invalid_polygon = loads(
+            "POLYGON ((40 100, 80 100, 80 60, 40 60, 40 100), "
+            "(60 60, 80 60, 80 40, 60 40, 60 60))"
+        )
+        assert not invalid_polygon.is_valid
+        if geos_version < (3, 13, 0):
+            with pytest.raises((TopologicalError, shapely.GEOSException)):
+                invalid_polygon.relate(invalid_polygon)
+        else:  # resolved with RelateNG
+            assert invalid_polygon.relate(invalid_polygon) == "2FFF1FFF2"
+
+    def test_hausdorff_distance(self):
+        point = Point(1, 1)
+        line = LineString([(2, 0), (2, 4), (3, 4)])
+
+        distance = point.hausdorff_distance(line)
+        assert distance == point.distance(Point(3, 4))
+
+    def test_interpolate(self):
+        # successful interpolation
+        test_line = LineString([(1, 1), (1, 2)])
+        known_point = Point(1, 1.5)
+        interpolated_point = test_line.interpolate(0.5, normalized=True)
+        assert interpolated_point == known_point
+
+        # Issue #653; should nog segfault for empty geometries
+        empty_line = loads("LINESTRING EMPTY")
+        assert empty_line.is_empty
+        interpolated_point = empty_line.interpolate(0.5, normalized=True)
+        assert interpolated_point.is_empty
+
+        # invalid geometry should raise TypeError on exception
+        polygon = loads("POLYGON EMPTY")
+        with pytest.raises(TypeError, match="incorrect geometry type"):
+            polygon.interpolate(0.5, normalized=True)
+
+    def test_normalize(self):
+        point = Point(1, 1)
+        result = point.normalize()
+        assert result == point
+
+        line = loads("MULTILINESTRING ((1 1, 0 0), (1 1, 1 2))")
+        result = line.normalize()
+        expected = loads("MULTILINESTRING ((1 1, 1 2), (0 0, 1 1))")
+        assert result == expected

grounding-dino/.eval_venv/lib/python3.11/site-packages/shapely/tests/legacy/test_operators.py

@@ -0,0 +1,60 @@
+import unittest
+
+from shapely.geometry import LineString, MultiPoint, Point, Polygon
+
+
+class OperatorsTestCase(unittest.TestCase):
+    def test_point(self):
+        point = Point(0, 0)
+        point2 = Point(-1, 1)
+        assert point.union(point2).equals(point | point2)
+        assert (point & point2).is_empty
+        assert point.equals(point - point2)
+        assert point.symmetric_difference(point2).equals(point ^ point2)
+        assert point != point2
+        point_dupe = Point(0, 0)
+        assert point, point_dupe
+
+    def test_multipoint(self):
+        mp1 = MultiPoint([(0, 0), (1, 1)])
+        mp1_dup = MultiPoint([(0, 0), (1, 1)])
+        mp1_rev = MultiPoint([(1, 1), (0, 0)])
+        mp2 = MultiPoint([(0, 0), (1, 1), (2, 2)])
+        mp3 = MultiPoint([(0, 0), (1, 1), (2, 3)])
+
+        assert mp1 == mp1_dup
+        assert mp1 != mp1_rev
+        assert mp1 != mp2
+        assert mp2 != mp3
+
+        p = Point(0, 0)
+        mp = MultiPoint([(0, 0)])
+        assert p != mp
+        assert mp != p
+
+    def test_polygon(self):
+        shell = ((0, 0), (3, 0), (3, 3), (0, 3))
+        hole = ((1, 1), (2, 1), (2, 2), (1, 2))
+        p_solid = Polygon(shell)
+        p2_solid = Polygon(shell)
+        p_hole = Polygon(shell, holes=[hole])
+        p2_hole = Polygon(shell, holes=[hole])
+
+        assert p_solid == p2_solid
+        assert p_hole == p2_hole
+        assert p_solid != p_hole
+
+        shell2 = ((-5, 2), (10.5, 3), (7, 3))
+        p3_hole = Polygon(shell2, holes=[hole])
+        assert p_hole != p3_hole
+
+    def test_linestring(self):
+        line1 = LineString([(0, 0), (1, 1), (2, 2)])
+        line2 = LineString([(0, 0), (2, 2)])
+        line2_dup = LineString([(0, 0), (2, 2)])
+        # .equals() indicates these are the same
+        assert line1.equals(line2)
+        # but != indicates these are different
+        assert line1 != line2
+        # but dupes are the same with ==
+        assert line2 == line2_dup

grounding-dino/.eval_venv/lib/python3.11/site-packages/shapely/tests/legacy/test_orient.py

@@ -0,0 +1,92 @@
+import unittest
+
+from numpy.testing import assert_array_equal
+
+from shapely.geometry import (
+    GeometryCollection,
+    LinearRing,
+    LineString,
+    MultiLineString,
+    MultiPoint,
+    MultiPolygon,
+    Point,
+    Polygon,
+)
+from shapely.ops import orient
+
+
+class OrientTestCase(unittest.TestCase):
+    def test_point(self):
+        point = Point(0, 0)
+        assert orient(point, 1) == point
+        assert orient(point, -1) == point
+
+    def test_multipoint(self):
+        multipoint = MultiPoint([(0, 0), (1, 1)])
+        assert orient(multipoint, 1) == multipoint
+        assert orient(multipoint, -1) == multipoint
+
+    def test_linestring(self):
+        linestring = LineString([(0, 0), (1, 1)])
+        assert orient(linestring, 1) == linestring
+        assert orient(linestring, -1) == linestring
+
+    def test_multilinestring(self):
+        multilinestring = MultiLineString([[(0, 0), (1, 1)], [(1, 0), (0, 1)]])
+        assert orient(multilinestring, 1) == multilinestring
+        assert orient(multilinestring, -1) == multilinestring
+
+    def test_linearring(self):
+        linearring = LinearRing([(0, 0), (0, 1), (1, 0)])
+        assert orient(linearring, 1) == linearring
+        assert orient(linearring, -1) == linearring
+
+    def test_empty_polygon(self):
+        polygon = Polygon()
+        assert orient(polygon) == polygon
+
+    def test_polygon(self):
+        polygon = Polygon([(0, 0), (0, 1), (1, 0)])
+        polygon_reversed = Polygon(polygon.exterior.coords[::-1])
+        assert (orient(polygon, 1)) == polygon_reversed
+        assert (orient(polygon, -1)) == polygon
+
+    def test_multipolygon(self):
+        polygon1 = Polygon([(0, 0), (0, 1), (1, 0)])
+        polygon2 = Polygon([(1, 0), (2, 0), (2, 1)])
+        polygon1_reversed = Polygon(polygon1.exterior.coords[::-1])
+        polygon2_reversed = Polygon(polygon2.exterior.coords[::-1])
+        multipolygon = MultiPolygon([polygon1, polygon2])
+        assert not polygon1.exterior.is_ccw
+        assert polygon2.exterior.is_ccw
+        assert orient(multipolygon, 1) == MultiPolygon([polygon1_reversed, polygon2])
+        assert orient(multipolygon, -1) == MultiPolygon([polygon1, polygon2_reversed])
+
+    def test_geometrycollection(self):
+        polygon = Polygon([(0, 0), (0, 1), (1, 0)])
+        polygon_reversed = Polygon(polygon.exterior.coords[::-1])
+        collection = GeometryCollection([polygon])
+        assert orient(collection, 1) == GeometryCollection([polygon_reversed])
+        assert orient(collection, -1) == GeometryCollection([polygon])
+
+    def test_polygon_with_holes(self):
+        ring_cw = LinearRing([(0, 0), (0, 1), (1, 1), (0, 0)])
+        ring_cw2 = LinearRing([(0, 0), (0, 3), (3, 3), (0, 0)])
+        ring_ccw = LinearRing([(0, 0), (1, 1), (0, 1), (0, 0)])
+        ring_ccw2 = LinearRing([(0, 0), (2, 2), (0, 2), (0, 0)])
+
+        polygon_with_holes_mixed = Polygon(
+            ring_ccw, [ring_cw, ring_ccw2, ring_cw2, ring_ccw]
+        )
+        polygon_with_holes_ccw = Polygon(
+            ring_ccw, [ring_cw, ring_ccw2.reverse(), ring_cw2, ring_ccw.reverse()]
+        )
+
+        assert_array_equal(orient(polygon_with_holes_ccw, 1), polygon_with_holes_ccw)
+        assert_array_equal(
+            orient(polygon_with_holes_ccw, -1), polygon_with_holes_ccw.reverse()
+        )
+        assert_array_equal(orient(polygon_with_holes_mixed, 1), polygon_with_holes_ccw)
+        assert_array_equal(
+            orient(polygon_with_holes_mixed, -1), polygon_with_holes_ccw.reverse()
+        )