feat(python): Constuctor for GeoArray (#1385)

Less typing than `GeoArray.from_arrow`

Author: kylebarron

python/geoarrow-core/python/geoarrow/rust/core/_array.pyi

@@ -6,6 +6,11 @@ from .enums import CoordType
 from .types import CoordTypeInput
 
 class GeoArray:
+    def __init__(self, data: ArrowArrayExportable) -> None:
+        """Create a new GeoArray.
+
+        At the moment this is solely an alias for `from_arrow()`.
+        """
     def __arrow_c_array__(
         self, requested_schema: object | None = None
     ) -> tuple[object, object]:

python/tests/core/operations/test_geometry_col.py

@@ -8,7 +8,7 @@
 
 def geoarrow_array():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    return GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    return GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
 
 
 def test_batch_no_geom_cols():

python/tests/core/operations/test_type_id.py

@@ -1,20 +1,19 @@
 import geopandas as gpd
 import numpy as np
 import shapely
-from arro3.core import ChunkedArray
 from geoarrow.rust.core import GeoArray, GeoChunkedArray, get_type_id
 
 
 def test_points():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     out = get_type_id(arr)
     assert (np.asarray(out) == 1).all()
 
 
 def test_points_wkb():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("wkb"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("wkb"))
     out = get_type_id(arr)
     assert (np.asarray(out) == 1).all()
 
@@ -41,7 +40,7 @@ def test_mixed_wkb():
             ]
         ),
     ]
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("wkb"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("wkb"))
     out = get_type_id(arr)
     assert (np.asarray(out) == np.array([1, 2, 3, 4, 5, 6, 7])).all()
 
@@ -68,7 +67,7 @@ def test_mixed_wkb_3d():
             ]
         ),
     ]
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("wkb"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("wkb"))
     out = get_type_id(arr)
     assert (np.asarray(out) == np.array([11, 12, 13, 14, 15, 16, 17])).all()
 
@@ -81,16 +80,16 @@ def test_multipoints():
             shapely.geometry.Point(3, 6),
         ]
     )
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     out = get_type_id(arr)
     assert (np.asarray(out) == 4).all()
 
 
 def test_points_chunked():
     geoms1 = shapely.points([1, 2, 3], [4, 5, 6])
     geoms2 = shapely.points([10, 20, 30], [40, 50, 60])
-    arr1 = GeoArray.from_arrow(gpd.GeoSeries(geoms1).to_arrow("geoarrow"))
-    arr2 = GeoArray.from_arrow(gpd.GeoSeries(geoms2).to_arrow("geoarrow"))
+    arr1 = GeoArray(gpd.GeoSeries(geoms1).to_arrow("geoarrow"))
+    arr2 = GeoArray(gpd.GeoSeries(geoms2).to_arrow("geoarrow"))
     ca = GeoChunkedArray([arr1, arr2])
     out = get_type_id(ca).read_all()
     assert (np.asarray(out) == 1).all()

python/tests/core/test_array.py

@@ -11,27 +11,27 @@
 
 def test_eq():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     assert arr == arr
 
     with registered_extension_types():
         pa_arr = pa.array(arr)
         assert arr == pa_arr
-        assert arr == GeoArray.from_arrow(pa_arr)
+        assert arr == GeoArray(pa_arr)
 
 
 def test_getitem():
     # Tests both the __getitem__ method and the scalar geo interface in round trip
     # conversion to shapely.
     gdf = gpd.read_file(geodatasets.get_path("ny.bb"))
-    arr = GeoArray.from_arrow(gdf.geometry.to_arrow("geoarrow"))
+    arr = GeoArray(gdf.geometry.to_arrow("geoarrow"))
     for i in range(len(arr)):
         assert shapely.geometry.shape(arr[i]).equals(gdf.geometry.iloc[i])  # type: ignore
 
 
 def test_repr():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     assert repr(arr) == 'GeoArray(Point(dimension="XY", coord_type="interleaved"))'
 
 

python/tests/core/test_chunked_array.py

@@ -12,8 +12,8 @@
 def test_eq():
     geoms1 = shapely.points([1, 2, 3], [4, 5, 6])
     geoms2 = shapely.points([10, 20, 30], [40, 50, 60])
-    arr1 = GeoArray.from_arrow(gpd.GeoSeries(geoms1).to_arrow("geoarrow"))
-    arr2 = GeoArray.from_arrow(gpd.GeoSeries(geoms2).to_arrow("geoarrow"))
+    arr1 = GeoArray(gpd.GeoSeries(geoms1).to_arrow("geoarrow"))
+    arr2 = GeoArray(gpd.GeoSeries(geoms2).to_arrow("geoarrow"))
     ca = GeoChunkedArray([arr1, arr2])
 
     assert ca == ca
@@ -28,8 +28,8 @@ def test_getitem():
     # Tests both the __getitem__ method and the scalar geo interface in round trip
     # conversion to shapely.
     gdf = gpd.read_file(geodatasets.get_path("ny.bb"))
-    arr1 = GeoArray.from_arrow(gdf.geometry.iloc[:2].to_arrow("geoarrow"))
-    arr2 = GeoArray.from_arrow(gdf.geometry.iloc[2:].to_arrow("geoarrow"))
+    arr1 = GeoArray(gdf.geometry.iloc[:2].to_arrow("geoarrow"))
+    arr2 = GeoArray(gdf.geometry.iloc[2:].to_arrow("geoarrow"))
     ca = GeoChunkedArray([arr1, arr2])
 
     for i in range(len(ca)):
@@ -39,8 +39,8 @@ def test_getitem():
 def test_repr():
     geoms1 = shapely.points([1, 2, 3], [4, 5, 6])
     geoms2 = shapely.points([10, 20, 30], [40, 50, 60])
-    arr1 = GeoArray.from_arrow(gpd.GeoSeries(geoms1).to_arrow("geoarrow"))
-    arr2 = GeoArray.from_arrow(gpd.GeoSeries(geoms2).to_arrow("geoarrow"))
+    arr1 = GeoArray(gpd.GeoSeries(geoms1).to_arrow("geoarrow"))
+    arr2 = GeoArray(gpd.GeoSeries(geoms2).to_arrow("geoarrow"))
     ca = GeoChunkedArray([arr1, arr2])
     assert (
         repr(ca) == 'GeoChunkedArray(Point(dimension="XY", coord_type="interleaved"))'
@@ -71,8 +71,8 @@ def test_downcast_with_crs():
 def constructor_existing_chunked_array():
     geoms1 = shapely.points([1, 2, 3], [4, 5, 6])
     geoms2 = shapely.points([10, 20, 30], [40, 50, 60])
-    arr1 = GeoArray.from_arrow(gpd.GeoSeries(geoms1).to_arrow("geoarrow"))
-    arr2 = GeoArray.from_arrow(gpd.GeoSeries(geoms2).to_arrow("geoarrow"))
+    arr1 = GeoArray(gpd.GeoSeries(geoms1).to_arrow("geoarrow"))
+    arr2 = GeoArray(gpd.GeoSeries(geoms2).to_arrow("geoarrow"))
     ca = ChunkedArray([arr1, arr2])
     geo_ca = GeoChunkedArray(ca)
     assert geo_ca.chunk(0) == arr1

python/tests/core/test_scalar.py

@@ -11,41 +11,41 @@
 
 def test_eq():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     assert arr[0] == arr[0]
 
     # pyarrow doesn't implement __arrow_c_array__ on scalars
     with registered_extension_types():
         pa_arr = pa.array(arr)
-        assert arr[0] == GeoArray.from_arrow(pa_arr)[0]
+        assert arr[0] == GeoArray(pa_arr)[0]
 
     # test with arro3
     assert arr[0] == Scalar.from_arrow(arr[0])
-    assert arr[0] == GeoArray.from_arrow(Scalar.from_arrow(arr[0]))[0]
+    assert arr[0] == GeoArray(Scalar.from_arrow(arr[0]))[0]
 
 
 def test_type():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     assert arr[0].type == point("xy", coord_type="interleaved")
 
 
 def test_repr():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     assert repr(arr[0]) == 'GeoScalar(Point(dimension="XY", coord_type="interleaved"))'
 
 
 def test_geo_interface():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
     gs = gpd.GeoSeries(geoms)
-    arr = GeoArray.from_arrow(gs.to_arrow("geoarrow"))
+    arr = GeoArray(gs.to_arrow("geoarrow"))
     assert geo_interface_equals(gs[0].__geo_interface__, arr[0].__geo_interface__)
 
 
 def test_geo_interface_polygon():
     gdf = gpd.read_file(geodatasets.get_path("ny.bb"))
-    arr = GeoArray.from_arrow(gdf.geometry.to_arrow("geoarrow"))
+    arr = GeoArray(gdf.geometry.to_arrow("geoarrow"))
     assert geo_interface_equals(
         gdf.geometry.iloc[0].__geo_interface__,
         arr[0].__geo_interface__,

python/tests/io/test_parquet.py

@@ -75,7 +75,7 @@ async def test_parquet_dataset():
 
 def test_write_wkb():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     table = Table.from_arrays([arr], names=["geometry"])
     with GeoParquetWriter("points.parquet", table.schema) as writer:
         writer.write_table(table)
@@ -96,7 +96,7 @@ def test_write_wkb():
 
 def test_write_wkb_covering():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     table = Table.from_arrays([arr], names=["geometry"])
     with GeoParquetWriter(
         "points.parquet", table.schema, generate_covering=True
@@ -143,7 +143,7 @@ def test_write_wkb_covering():
 
 def test_write_geoarrow():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     table = Table.from_arrays([arr], names=["geometry"])
     with GeoParquetWriter(
         "points.parquet", table.schema, encoding="geoarrow"
@@ -170,7 +170,7 @@ def test_write_geoarrow():
 
 def test_write_geoarrow_xyz():
     geoms = shapely.points([1, 2, 3], [4, 5, 6], [7, 8, 9])
-    arr = GeoArray.from_arrow(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
+    arr = GeoArray(gpd.GeoSeries(geoms).to_arrow("geoarrow"))
     table = Table.from_arrays([arr], names=["geometry"])
     with GeoParquetWriter(
         "points.parquet", table.schema, encoding="geoarrow"
@@ -203,7 +203,7 @@ def test_write_crs():
     geoms = shapely.points([1, 2, 3], [4, 5, 6])
     crs = CRS.from_user_input("EPSG:4326")
     series = gpd.GeoSeries(geoms, crs=crs)
-    arr = GeoArray.from_arrow(series.to_arrow("geoarrow"))
+    arr = GeoArray(series.to_arrow("geoarrow"))
     table = Table.from_arrays([arr], names=["geometry"])
     with GeoParquetWriter("points.parquet", table.schema) as writer:
         writer.write_table(table)

rust/pyo3-geoarrow/src/array.rs

@@ -82,8 +82,8 @@ impl PyGeoArray {
 #[pymethods]
 impl PyGeoArray {
     #[new]
-    fn py_new(data: &Bound<PyAny>) -> PyResult<Self> {
-        data.extract()
+    fn py_new(data: Self) -> Self {
+        data
     }
 
     #[pyo3(signature = (requested_schema=None))]