def test_dataframe_to_geodataframe(self): df = pd.DataFrame({"A": range(len(self.df)), "location": list(self.df.geometry)}, index=self.df.index) gf = df.set_geometry('location', crs=self.df.crs) assert isinstance(df, pd.DataFrame) assert isinstance(gf, GeoDataFrame) assert_geoseries_equal(gf.geometry, self.df.geometry) assert gf.geometry.name == 'location' assert 'geometry' not in gf gf2 = df.set_geometry('location', crs=self.df.crs, drop=True) assert isinstance(df, pd.DataFrame) assert isinstance(gf2, GeoDataFrame) assert gf2.geometry.name == 'geometry' assert 'geometry' in gf2 assert 'location' not in gf2 assert 'location' in df # should be a copy df.loc[0, "A"] = 100 assert gf.loc[0, "A"] == 0 assert gf2.loc[0, "A"] == 0 with pytest.raises(ValueError): df.set_geometry('location', inplace=True)
def test_set_geometry_col(self): g = self.df.geometry g_simplified = g.simplify(100) self.df['simplified_geometry'] = g_simplified df2 = self.df.set_geometry('simplified_geometry') # Drop is false by default assert 'simplified_geometry' in df2 assert_geoseries_equal(df2.geometry, g_simplified) # If True, drops column and renames to geometry df3 = self.df.set_geometry('simplified_geometry', drop=True) assert 'simplified_geometry' not in df3 assert_geoseries_equal(df3.geometry, g_simplified)
def test_to_file_datetime(tmpdir): """Test writing a data file with the datetime column type""" tempfilename = os.path.join(str(tmpdir), "test_datetime.gpkg") point = Point(0, 0) now = datetime.datetime.now() df = GeoDataFrame({ "a": [1, 2], "b": [now, now] }, geometry=[point, point], crs={}) df.to_file(tempfilename, driver="GPKG") df_read = read_file(tempfilename) assert_geoseries_equal(df.geometry, df_read.geometry)
def test_set_geometry_col(self): g = self.df.geometry g_simplified = g.simplify(100) self.df['simplified_geometry'] = g_simplified df2 = self.df.set_geometry('simplified_geometry') # Drop is false by default assert 'simplified_geometry' in df2 assert_geoseries_equal(df2.geometry, g_simplified) # If True, drops column and renames to geometry df3 = self.df.set_geometry('simplified_geometry', drop=True) assert 'simplified_geometry' not in df3 assert_geoseries_equal(df3.geometry, g_simplified)
def test_reindex(s, df): # GeoSeries reindex res = s.reindex([1, 2, 3]) exp = GeoSeries([Point(1, 1), Point(2, 2), None], index=[1, 2, 3]) assert_geoseries_equal(res, exp) # GeoDataFrame reindex index res = df.reindex(index=[1, 2, 3]) assert_geoseries_equal(res.geometry, exp) # GeoDataFrame reindex columns res = df.reindex(columns=["value1", "geometry"]) assert isinstance(res, GeoDataFrame) assert isinstance(res.geometry, GeoSeries) assert_frame_equal(res, df[["value1", "geometry"]])
def test_different_geo_colname(self): data = { "A": range(5), "B": range(-5, 0), "location": [Point(x, y) for x, y in zip(range(5), range(5))], } df = GeoDataFrame(data, crs=self.crs, geometry="location") locs = GeoSeries(data["location"], crs=self.crs) assert_geoseries_equal(df.geometry, locs) assert "geometry" not in df assert df.geometry.name == "location" # internal implementation detail assert df._geometry_column_name == "location" geom2 = [Point(x, y) for x, y in zip(range(5, 10), range(5))] with pytest.raises(CRSError): df.set_geometry(geom2, crs="dummy_crs")
def test_apply(s): # function that returns geometry preserves GeoSeries class def geom_func(geom): assert isinstance(geom, Point) return geom result = s.apply(geom_func) assert isinstance(result, GeoSeries) assert_geoseries_equal(result, s) # function that returns non-geometry results in Series def numeric_func(geom): assert isinstance(geom, Point) return geom.x result = s.apply(numeric_func) assert not isinstance(result, GeoSeries) assert_series_equal(result, pd.Series([0.0, 1.0, 2.0]))
def test_different_geo_colname(self): data = {"A": range(5), "B": range(-5, 0), "location": [Point(x, y) for x, y in zip(range(5), range(5))]} df = GeoDataFrame(data, crs=self.crs, geometry='location') locs = GeoSeries(data['location'], crs=self.crs) assert_geoseries_equal(df.geometry, locs) assert 'geometry' not in df assert df.geometry.name == 'location' # internal implementation detail assert df._geometry_column_name == 'location' geom2 = [Point(x, y) for x, y in zip(range(5, 10), range(5))] df2 = df.set_geometry(geom2, crs='dummy_crs') assert 'location' in df2 assert df2.crs == 'dummy_crs' assert df2.geometry.crs == 'dummy_crs' # reset so it outputs okay df2.crs = df.crs assert_geoseries_equal(df2.geometry, GeoSeries(geom2, crs=df2.crs))
def test_geometry_not_named_geometry(dfs, how, other_geometry): # Issue #306 # Add points and flip names df1, df2 = dfs df3 = df1.copy() df3 = df3.rename(columns={"geometry": "polygons"}) df3 = df3.set_geometry("polygons") if other_geometry: df3["geometry"] = df1.centroid.geometry assert df3.geometry.name == "polygons" res1 = overlay(df1, df2, how=how) res2 = overlay(df3, df2, how=how) assert df3.geometry.name == "polygons" if how == "difference": # in case of 'difference', column names of left frame are preserved assert res2.geometry.name == "polygons" if other_geometry: assert "geometry" in res2.columns assert_geoseries_equal(res2["geometry"], df3["geometry"], check_series_type=False) res2 = res2.drop(["geometry"], axis=1) res2 = res2.rename(columns={"polygons": "geometry"}) res2 = res2.set_geometry("geometry") # TODO if existing column is overwritten -> geometry not last column if other_geometry and how == "intersection": res2 = res2.reindex(columns=res1.columns) assert_geodataframe_equal(res1, res2) df4 = df2.copy() df4 = df4.rename(columns={"geometry": "geom"}) df4 = df4.set_geometry("geom") if other_geometry: df4["geometry"] = df2.centroid.geometry assert df4.geometry.name == "geom" res1 = overlay(df1, df2, how=how) res2 = overlay(df1, df4, how=how) assert_geodataframe_equal(res1, res2)
def test_different_geo_colname(self): data = {"A": range(5), "B": range(-5, 0), "location": [Point(x, y) for x, y in zip(range(5), range(5))]} df = GeoDataFrame(data, crs=self.crs, geometry='location') locs = GeoSeries(data['location'], crs=self.crs) assert_geoseries_equal(df.geometry, locs) assert 'geometry' not in df assert df.geometry.name == 'location' # internal implementation detail assert df._geometry_column_name == 'location' geom2 = [Point(x, y) for x, y in zip(range(5, 10), range(5))] df2 = df.set_geometry(geom2, crs='dummy_crs') assert 'location' in df2 assert df2.crs == 'dummy_crs' assert df2.geometry.crs == 'dummy_crs' # reset so it outputs okay df2.crs = df.crs assert_geoseries_equal(df2.geometry, GeoSeries(geom2, crs=df2.crs))
def test_geometry_not_named_geometry(dfs, how, other_geometry): # Issue #306 # Add points and flip names df1, df2 = dfs df3 = df1.copy() df3 = df3.rename(columns={'geometry': 'polygons'}) df3 = df3.set_geometry('polygons') if other_geometry: df3['geometry'] = df1.centroid.geometry assert df3.geometry.name == 'polygons' res1 = overlay(df1, df2, how=how) res2 = overlay(df3, df2, how=how) assert df3.geometry.name == 'polygons' if how == 'difference': # in case of 'difference', column names of left frame are preserved assert res2.geometry.name == 'polygons' if other_geometry: assert 'geometry' in res2.columns assert_geoseries_equal(res2['geometry'], df3['geometry'], check_series_type=False) res2 = res2.drop(['geometry'], axis=1) res2 = res2.rename(columns={'polygons': 'geometry'}) res2 = res2.set_geometry('geometry') # TODO if existing column is overwritten -> geometry not last column if other_geometry and how == 'intersection': res2 = res2.reindex(columns=res1.columns) assert_geodataframe_equal(res1, res2) df4 = df2.copy() df4 = df4.rename(columns={'geometry': 'geom'}) df4 = df4.set_geometry('geom') if other_geometry: df4['geometry'] = df2.centroid.geometry assert df4.geometry.name == 'geom' res1 = overlay(df1, df2, how=how) res2 = overlay(df1, df4, how=how) assert_geodataframe_equal(res1, res2)
def test_geometry_not_named_geometry(dfs, how, other_geometry): # Issue #306 # Add points and flip names df1, df2 = dfs df3 = df1.copy() df3 = df3.rename(columns={'geometry': 'polygons'}) df3 = df3.set_geometry('polygons') if other_geometry: df3['geometry'] = df1.centroid.geometry assert df3.geometry.name == 'polygons' res1 = overlay(df1, df2, how=how) res2 = overlay(df3, df2, how=how) assert df3.geometry.name == 'polygons' if how == 'difference': # in case of 'difference', column names of left frame are preserved assert res2.geometry.name == 'polygons' if other_geometry: assert 'geometry' in res2.columns assert_geoseries_equal(res2['geometry'], df3['geometry'], check_series_type=False) res2 = res2.drop(['geometry'], axis=1) res2 = res2.rename(columns={'polygons': 'geometry'}) res2 = res2.set_geometry('geometry') # TODO if existing column is overwritten -> geometry not last column if other_geometry and how == 'intersection': res2 = res2.reindex(columns=res1.columns) assert_geodataframe_equal(res1, res2) df4 = df2.copy() df4 = df4.rename(columns={'geometry': 'geom'}) df4 = df4.set_geometry('geom') if other_geometry: df4['geometry'] = df2.centroid.geometry assert df4.geometry.name == 'geom' res1 = overlay(df1, df2, how=how) res2 = overlay(df1, df4, how=how) assert_geodataframe_equal(res1, res2)
def test_parquet_multiple_geom_cols(tmpdir): """If multiple geometry columns are present when written to parquet, they should all be returned as such when read from parquet. """ test_dataset = "naturalearth_lowres" df = read_file(get_path(test_dataset)) df["geom2"] = df.geometry.copy() filename = os.path.join(str(tmpdir), "test.pq") df.to_parquet(filename) assert os.path.exists(filename) pq_df = read_parquet(filename) assert isinstance(pq_df, GeoDataFrame) assert_geodataframe_equal(df, pq_df) assert_geoseries_equal(df.geom2, pq_df.geom2, check_geom_type=True)
def test_roundtrip(tmp_path): # basic roundtrip df = geopandas.read_file( geopandas.datasets.get_path("naturalearth_lowres")) ddf = dask_geopandas.from_geopandas(df, npartitions=4) basedir = tmp_path / "dataset" ddf.to_feather(basedir) # reading back gives identical GeoDataFrame result = dask_geopandas.read_feather(basedir) assert result.npartitions == 4 assert result.crs == df.crs # TODO this reset_index should not be necessary result_gpd = result.compute().reset_index(drop=True) assert_geodataframe_equal(result_gpd, df) # reading back also populates the spatial partitioning property ddf.calculate_spatial_partitions() assert_geoseries_equal(result.spatial_partitions, ddf.spatial_partitions.envelope)
def test_set_geometry(self): geom = GeoSeries([Point(x, y) for x, y in zip(range(5), range(5))]) original_geom = self.df.geometry df2 = self.df.set_geometry(geom) assert self.df is not df2 assert_geoseries_equal(df2.geometry, geom) assert_geoseries_equal(self.df.geometry, original_geom) assert_geoseries_equal(self.df['geometry'], self.df.geometry) # unknown column with pytest.raises(ValueError): self.df.set_geometry('nonexistent-column') # ndim error with pytest.raises(ValueError): self.df.set_geometry(self.df) # new crs - setting should default to GeoSeries' crs gs = GeoSeries(geom, crs="epsg:26018") new_df = self.df.set_geometry(gs) assert new_df.crs == "epsg:26018" # explicit crs overrides self and dataframe new_df = self.df.set_geometry(gs, crs="epsg:27159") assert new_df.crs == "epsg:27159" assert new_df.geometry.crs == "epsg:27159" # Series should use dataframe's new_df = self.df.set_geometry(geom.values) assert new_df.crs == self.df.crs assert new_df.geometry.crs == self.df.crs
def test_set_geometry(self): geom = GeoSeries([Point(x, y) for x, y in zip(range(5), range(5))]) original_geom = self.df.geometry df2 = self.df.set_geometry(geom) assert self.df is not df2 assert_geoseries_equal(df2.geometry, geom, check_crs=False) assert_geoseries_equal(self.df.geometry, original_geom) assert_geoseries_equal(self.df["geometry"], self.df.geometry) # unknown column with pytest.raises(ValueError): self.df.set_geometry("nonexistent-column") # ndim error with pytest.raises(ValueError): self.df.set_geometry(self.df) # new crs - setting should default to GeoSeries' crs gs = GeoSeries(geom, crs="epsg:3857") new_df = self.df.set_geometry(gs) assert new_df.crs == "epsg:3857" # explicit crs overrides self and dataframe new_df = self.df.set_geometry(gs, crs="epsg:26909") assert new_df.crs == "epsg:26909" assert new_df.geometry.crs == "epsg:26909" # Series should use dataframe's new_df = self.df.set_geometry(geom.values) assert new_df.crs == self.df.crs assert new_df.geometry.crs == self.df.crs
def test_assignment(s, df): exp = GeoSeries([Point(10, 10), Point(1, 1), Point(2, 2)]) s2 = s.copy() s2[0] = Point(10, 10) assert_geoseries_equal(s2, exp) s2 = s.copy() s2.loc[0] = Point(10, 10) assert_geoseries_equal(s2, exp) s2 = s.copy() s2.iloc[0] = Point(10, 10) assert_geoseries_equal(s2, exp) df2 = df.copy() df2.loc[0, "geometry"] = Point(10, 10) assert_geoseries_equal(df2["geometry"], exp) df2 = df.copy() df2.iloc[0, 0] = Point(10, 10) assert_geoseries_equal(df2["geometry"], exp)
def test_read_file_columns(): path = geopandas.datasets.get_path("naturalearth_lowres") df = geopandas.read_file(path) # explicit column selection result = dask_geopandas.read_file(path, npartitions=4, columns=["pop_est", "geometry"]) assert isinstance(result, dask_geopandas.GeoDataFrame) assert result.npartitions == 4 assert result.crs == df.crs assert len(result.columns) == 2 assert_geodataframe_equal(result.compute(), df[["pop_est", "geometry"]]) # only selecting non-geometry column result = dask_geopandas.read_file(path, npartitions=4, columns=["pop_est"]) assert type(result) == dd.DataFrame assert len(result.columns) == 1 assert result.npartitions == 4 assert_frame_equal(result.compute(), df[["pop_est"]]) # column selection through getitem ddf = dask_geopandas.read_file(path, npartitions=4) result = ddf[["pop_est", "geometry"]] assert isinstance(result, dask_geopandas.GeoDataFrame) assert result.npartitions == 4 assert result.crs == df.crs assert_geodataframe_equal(result.compute(), df[["pop_est", "geometry"]]) # only select non-geometry column result = ddf["pop_est"] assert isinstance(result, dd.Series) assert_series_equal(result.compute(), df["pop_est"]) # only select geometry column result = ddf["geometry"] assert isinstance(result, dask_geopandas.GeoSeries) assert_geoseries_equal(result.compute(), df["geometry"])
def test_fillna(s, df): s2 = GeoSeries([Point(0, 0), None, Point(2, 2)]) res = s2.fillna(Point(1, 1)) assert_geoseries_equal(res, s) # allow np.nan although this does not change anything # https://github.com/geopandas/geopandas/issues/1149 res = s2.fillna(np.nan) assert_geoseries_equal(res, s2) # raise exception if trying to fill missing geometry w/ non-geometry df2 = df.copy() df2["geometry"] = s2 res = df2.fillna(Point(1, 1)) assert_geodataframe_equal(res, df) with pytest.raises(NotImplementedError): df2.fillna(0) # allow non-geometry fill value if there are no missing values # https://github.com/geopandas/geopandas/issues/1149 df3 = df.copy() df3.loc[0, "value1"] = np.nan res = df3.fillna(0) assert_geodataframe_equal(res.astype({"value1": "int64"}), df)
def test_geo_setitem(self): data = { "A": range(5), "B": np.arange(5.), "geometry": [Point(x, y) for x, y in zip(range(5), range(5))] } df = GeoDataFrame(data) s = GeoSeries([Point(x, y + 1) for x, y in zip(range(5), range(5))]) # setting geometry column for vals in [s, s.values]: df['geometry'] = vals assert_geoseries_equal(df['geometry'], s) assert_geoseries_equal(df.geometry, s) # non-aligned values s2 = GeoSeries([Point(x, y + 1) for x, y in zip(range(6), range(6))]) df['geometry'] = s2 assert_geoseries_equal(df['geometry'], s) assert_geoseries_equal(df.geometry, s)
def test_geo_setitem(self): data = { "A": range(5), "B": np.arange(5.0), "geometry": [Point(x, y) for x, y in zip(range(5), range(5))], } df = GeoDataFrame(data) s = GeoSeries([Point(x, y + 1) for x, y in zip(range(5), range(5))]) # setting geometry column for vals in [s, s.values]: df["geometry"] = vals assert_geoseries_equal(df["geometry"], s) assert_geoseries_equal(df.geometry, s) # non-aligned values s2 = GeoSeries([Point(x, y + 1) for x, y in zip(range(6), range(6))]) df["geometry"] = s2 assert_geoseries_equal(df["geometry"], s) assert_geoseries_equal(df.geometry, s) # setting other column with geometry values -> preserve geometry type for vals in [s, s.values]: df["other_geom"] = vals assert isinstance(df["other_geom"].values, GeometryArray) # overwriting existing non-geometry column -> preserve geometry type data = { "A": range(5), "B": np.arange(5.0), "other_geom": range(5), "geometry": [Point(x, y) for x, y in zip(range(5), range(5))], } df = GeoDataFrame(data) for vals in [s, s.values]: df["other_geom"] = vals assert isinstance(df["other_geom"].values, GeometryArray)
def test_geometry_property(self): assert_geoseries_equal(self.df.geometry, self.df['geometry'], check_dtype=True, check_index_type=True) df = self.df.copy() new_geom = [Point(x, y) for x, y in zip(range(len(self.df)), range(len(self.df)))] df.geometry = new_geom new_geom = GeoSeries(new_geom, index=df.index, crs=df.crs) assert_geoseries_equal(df.geometry, new_geom) assert_geoseries_equal(df['geometry'], new_geom) # new crs gs = GeoSeries(new_geom, crs="epsg:26018") df.geometry = gs assert df.crs == "epsg:26018"
def test_geometry_property(self): assert_geoseries_equal(self.df.geometry, self.df['geometry'], check_dtype=True, check_index_type=True) df = self.df.copy() new_geom = [Point(x, y) for x, y in zip(range(len(self.df)), range(len(self.df)))] df.geometry = new_geom new_geom = GeoSeries(new_geom, index=df.index, crs=df.crs) assert_geoseries_equal(df.geometry, new_geom) assert_geoseries_equal(df['geometry'], new_geom) # new crs gs = GeoSeries(new_geom, crs="epsg:26018") df.geometry = gs assert df.crs == "epsg:26018"
def test_propagate_on_geometry_access(): # ensure the spatial_partitioning information is preserved in GeoSeries df = geopandas.read_file( geopandas.datasets.get_path("naturalearth_lowres")) ddf = dask_geopandas.from_geopandas(df, npartitions=4) ddf.calculate_spatial_partitions() spatial_partitions = ddf.spatial_partitions.copy() # geometry attribute gs = ddf.geometry assert gs.spatial_partitions is not None assert_geoseries_equal(gs.spatial_partitions, spatial_partitions) # column access gs = ddf["geometry"] assert gs.spatial_partitions is not None assert_geoseries_equal(gs.spatial_partitions, spatial_partitions) # subset geodataframe subset = ddf[["continent", "geometry"]] assert subset.spatial_partitions is not None assert_geoseries_equal(subset.spatial_partitions, spatial_partitions)
def test_from_wkt(self): assert_geoseries_equal(self.g1, GeoSeries.from_wkt([self.t1.wkt, self.sq.wkt]))
def test_set_geometry_inplace(self): geom = [Point(x, y) for x, y in zip(range(5), range(5))] ret = self.df.set_geometry(geom, inplace=True) assert ret is None geom = GeoSeries(geom, index=self.df.index, crs=self.df.crs) assert_geoseries_equal(self.df.geometry, geom)
def test_equal_nans(): s = GeoSeries([Point(0, 0), np.nan]) assert_geoseries_equal(s, s.copy()) assert_geoseries_equal(s, s.copy(), check_less_precise=True)
def test_geoseries(): assert_geoseries_equal(s1, s2) with pytest.raises(AssertionError): assert_geoseries_equal(s1, s2, check_less_precise=True)
def test_indexing(s, df): # accessing scalar from the geometry (colunm) exp = Point(1, 1) assert s[1] == exp assert s.loc[1] == exp assert s.iloc[1] == exp assert df.loc[1, "geometry"] == exp assert df.iloc[1, 0] == exp # multiple values exp = GeoSeries([Point(2, 2), Point(0, 0)], index=[2, 0]) assert_geoseries_equal(s.loc[[2, 0]], exp) assert_geoseries_equal(s.iloc[[2, 0]], exp) assert_geoseries_equal(s.reindex([2, 0]), exp) assert_geoseries_equal(df.loc[[2, 0], "geometry"], exp) # TODO here iloc does not return a GeoSeries assert_series_equal(df.iloc[[2, 0], 0], exp, check_series_type=False, check_names=False) # boolean indexing exp = GeoSeries([Point(0, 0), Point(2, 2)], index=[0, 2]) mask = np.array([True, False, True]) assert_geoseries_equal(s[mask], exp) assert_geoseries_equal(s.loc[mask], exp) assert_geoseries_equal(df[mask]["geometry"], exp) assert_geoseries_equal(df.loc[mask, "geometry"], exp) # slices s.index = [1, 2, 3] exp = GeoSeries([Point(1, 1), Point(2, 2)], index=[2, 3]) assert_series_equal(s[1:], exp) assert_series_equal(s.iloc[1:], exp) assert_series_equal(s.loc[2:], exp)
def test_dropna(): s2 = GeoSeries([Point(0, 0), None, Point(2, 2)]) res = s2.dropna() exp = s2.loc[[0, 2]] assert_geoseries_equal(res, exp)
def test_apply_convert_dtypes_keyword(s): # ensure the convert_dtypes keyword is accepted res = s.apply(lambda x: x, convert_dtype=True, args=()) assert_geoseries_equal(res, s)
def test_almost_equal_but_not_equal(): s_origin = GeoSeries([Point(0, 0)]) s_almost_origin = GeoSeries([Point(0.0000001, 0)]) assert_geoseries_equal(s_origin, s_almost_origin, check_less_precise=True) with pytest.raises(AssertionError): assert_geoseries_equal(s_origin, s_almost_origin)
def test_geoseries(): assert_geoseries_equal(s1, s2) with pytest.raises(AssertionError): assert_geoseries_equal(s1, s2, check_less_precise=True)
def test_set_geometry_inplace(self): geom = [Point(x, y) for x, y in zip(range(5), range(5))] ret = self.df.set_geometry(geom, inplace=True) assert ret is None geom = GeoSeries(geom, index=self.df.index, crs=self.df.crs) assert_geoseries_equal(self.df.geometry, geom)
def test_from_wkt_series(self): s = pd.Series([self.t1.wkt, self.sq.wkt], index=[1, 2]) expected = self.g1.copy() expected.index = pd.Index([1, 2]) assert_geoseries_equal(expected, GeoSeries.from_wkt(s))
def test_equal_nans(): s = GeoSeries([Point(0, 0), np.nan]) assert_geoseries_equal(s, s.copy()) assert_geoseries_equal(s, s.copy(), check_less_precise=True)
def test_from_wkt_series_with_index(self): index = [0] s = pd.Series([self.t1.wkt, self.sq.wkt], index=[0, 2]) expected = self.g1.reindex(index) assert_geoseries_equal(expected, GeoSeries.from_wkt(s, index=index))
def test_geoseries(): assert_geoseries_equal(s1, s2) assert_geoseries_equal(s1, s3, check_series_type=False, check_dtype=False) assert_geoseries_equal(s3, s2, check_series_type=False, check_dtype=False) assert_geoseries_equal(s1, s4, check_series_type=False) with pytest.raises(AssertionError) as error: assert_geoseries_equal(s1, s2, check_less_precise=True) assert "1 out of 2 geometries are not almost equal" in str(error.value) assert "not almost equal: [0]" in str(error.value) with pytest.raises(AssertionError) as error: assert_geoseries_equal(s2, s6, check_less_precise=False) assert "1 out of 2 geometries are not equal" in str(error.value) assert "not equal: [0]" in str(error.value)
def test_from_xy_points_indexless(self): x = np.array([0.0, 3.0]) y = np.array([2.0, 5.0]) z = np.array([-1.0, 4.0]) expected = GeoSeries([Point(0, 2, -1), Point(3, 5, 4)]) assert_geoseries_equal(expected, GeoSeries.from_xy(x, y, z))