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))
