def test_read_file(self):
df = self.df.rename(columns=lambda x: x.lower())
validate_boro_df(df)
assert df.crs == self.crs
# get lower case columns, and exclude geometry column from comparison
lower_columns = [c.lower() for c in self.columns]
assert (df.columns[:-1] == lower_columns).all()
def test_from_postgis_default(self, connection_postgis, df_nybb):
con = connection_postgis
create_postgis(con, df_nybb)
sql = "SELECT * FROM nybb;"
df = GeoDataFrame.from_postgis(sql, con)
validate_boro_df(df, case_sensitive=False)
def test_read_sqlite(tmpdir, nybb_df):
tmp_filename = os.path.join(str(tmpdir), "nybb.sqlite")
create_sqlite(nybb_df, tmp_filename)
con = sqlite3.connect(tmp_filename)
try:
sqlite_df = read_sql("SELECT * FROM nybb;", con, hex_encoded=False)
finally:
con.close()
validate_boro_df(sqlite_df)
def test_read_postgis_binary(self, connection_spatialite, df_nybb):
"""Tests that geometry read as binary is accepted."""
con = connection_spatialite
geom_col = df_nybb.geometry.name
create_spatialite(con, df_nybb)
sql = ("SELECT ogc_fid, borocode, boroname, shape_leng, shape_area, "
'ST_AsBinary("{0}") AS "{0}" FROM nybb'.format(geom_col))
df = read_postgis(sql, con, geom_col=geom_col)
validate_boro_df(df)
def test_from_postgis_custom_geom_col(self, connection_postgis, df_nybb):
con = connection_postgis
geom_col = "the_geom"
create_postgis(con, df_nybb, geom_col=geom_col)
sql = "SELECT * FROM nybb;"
df = GeoDataFrame.from_postgis(sql, con, geom_col=geom_col)
validate_boro_df(df, case_sensitive=False)
def test_from_features(self):
nybb_filename = geopandas.datasets.get_path("nybb")
with fiona.open(nybb_filename) as f:
features = list(f)
crs = f.crs
df = GeoDataFrame.from_features(features, crs=crs)
validate_boro_df(df, case_sensitive=True)
assert df.crs == crs
def test_from_features(self):
nybb_filename = geopandas.datasets.get_path('nybb')
with fiona.open(nybb_filename) as f:
features = list(f)
crs = f.crs
df = GeoDataFrame.from_features(features, crs=crs)
validate_boro_df(df, case_sensitive=True)
assert df.crs == crs
def test_read_postgis_custom_geom_col(self, connection_postgis, df_nybb):
con = connection_postgis
geom_col = "the_geom"
create_postgis(con, df_nybb, geom_col=geom_col)
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con, geom_col=geom_col)
validate_boro_df(df)
def test_read_postgis_null_geom(self, connection_spatialite, df_nybb):
"""Tests that geometry with NULL is accepted."""
con = connection_spatialite
geom_col = df_nybb.geometry.name
df_nybb.geometry.iat[0] = None
create_spatialite(con, df_nybb)
sql = ("SELECT ogc_fid, borocode, boroname, shape_leng, shape_area, "
'AsEWKB("{0}") AS "{0}" FROM nybb'.format(geom_col))
df = read_postgis(sql, con, geom_col=geom_col)
validate_boro_df(df)
def test_from_features(self):
nybb_filename = geopandas.datasets.get_path('nybb')
with fiona.open(nybb_filename) as f:
features = list(f)
crs = f.crs
df = GeoDataFrame.from_features(features, crs=crs)
df.rename(columns=lambda x: x.lower(), inplace=True)
validate_boro_df(self, df)
self.assert_(df.crs == crs)
def test_from_features(self):
nybb_filename = geopandas.datasets.get_path('nybb')
with fiona.open(nybb_filename) as f:
features = list(f)
crs = f.crs
df = GeoDataFrame.from_features(features, crs=crs)
df.rename(columns=lambda x: x.lower(), inplace=True)
validate_boro_df(df)
assert df.crs == crs
def test_from_features(self):
nybb_filename, nybb_zip_path = download_nybb()
with fiona.open(nybb_zip_path, vfs='zip://' + nybb_filename) as f:
features = list(f)
crs = f.crs
df = GeoDataFrame.from_features(features, crs=crs)
df.rename(columns=lambda x: x.lower(), inplace=True)
validate_boro_df(self, df)
self.assert_(df.crs == crs)
def test_read_postgis_default(self, connection_postgis, df_nybb):
con = connection_postgis
create_postgis(con, df_nybb)
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con)
validate_boro_df(df)
# no crs defined on the created geodatabase, and none specified
# by user; should not be set to 0, as from get_srid failure
assert df.crs is None
def test_read_postgis_override_srid(self, connection_postgis, df_nybb):
"""Tests that a user specified CRS overrides the geodatabase SRID."""
con = connection_postgis
orig_crs = df_nybb.crs
create_postgis(con, df_nybb, srid=4269)
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con, crs=orig_crs)
validate_boro_df(df)
assert df.crs == orig_crs
def test_from_features(self):
nybb_filename, nybb_zip_path = download_nybb()
with fiona.open(nybb_zip_path,
vfs='zip://' + nybb_filename) as f:
features = list(f)
crs = f.crs
df = GeoDataFrame.from_features(features, crs=crs)
df.rename(columns=lambda x: x.lower(), inplace=True)
validate_boro_df(self, df)
self.assert_(df.crs == crs)
def test_read_postgis_select_geom_as(self, connection_postgis, df_nybb):
"""Tests that a SELECT {geom} AS {some_other_geom} works."""
con = connection_postgis
orig_geom = "geom"
out_geom = "the_geom"
create_postgis(con, df_nybb, geom_col=orig_geom)
sql = """SELECT borocode, boroname, shape_leng, shape_area,
{} as {} FROM nybb;""".format(orig_geom, out_geom)
df = read_postgis(sql, con, geom_col=out_geom)
validate_boro_df(df)
def test_read_postgis_get_srid(self, connection_postgis, df_nybb):
"""Tests that an SRID can be read from a geodatabase (GH #451)."""
con = connection_postgis
crs = "epsg:4269"
df_reproj = df_nybb.to_crs(crs)
create_postgis(con, df_reproj, srid=4269)
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con)
validate_boro_df(df)
assert df.crs == crs
def test_from_postgis_default(self):
con = connect('test_geopandas')
if con is None or not create_db(self.df):
raise unittest.case.SkipTest()
try:
sql = "SELECT * FROM nybb;"
df = GeoDataFrame.from_postgis(sql, con)
finally:
con.close()
validate_boro_df(self, df)
def test_from_postgis_default(self):
con = connect('test_geopandas')
if con is None or not create_db(self.df):
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = GeoDataFrame.from_postgis(sql, con)
finally:
con.close()
validate_boro_df(df, case_sensitive=False)
def test_from_postgis_default(self):
con = connect("test_geopandas")
if con is None or not create_postgis(self.df):
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = GeoDataFrame.from_postgis(sql, con)
finally:
con.close()
validate_boro_df(df, case_sensitive=False)
def test_read_postgis_default(self):
con = connect('test_geopandas')
if con is None or not create_db(self.df):
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con)
finally:
con.close()
validate_boro_df(df)
def test_from_postgis_custom_geom_col(self):
con = connect('test_geopandas')
geom_col = "the_geom"
if con is None or not create_postgis(self.df, geom_col=geom_col):
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = GeoDataFrame.from_postgis(sql, con, geom_col=geom_col)
finally:
con.close()
validate_boro_df(df, case_sensitive=False)
def test_from_postgis_custom_geom_col(self):
con = connect('test_geopandas')
geom_col = "the_geom"
if con is None or not create_postgis(self.df, geom_col=geom_col):
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = GeoDataFrame.from_postgis(sql, con, geom_col=geom_col)
finally:
con.close()
validate_boro_df(df, case_sensitive=False)
def test_read_postgis_custom_geom_col(self):
con = connect('test_geopandas')
geom_col = "the_geom"
if con is None or not create_postgis(self.df, geom_col=geom_col):
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con, geom_col=geom_col)
finally:
con.close()
validate_boro_df(df)
def test_read_postgis_chunksize(self, connection_postgis, df_nybb):
"""Test chunksize argument"""
chunksize = 2
con = connection_postgis
create_postgis(con, df_nybb)
sql = "SELECT * FROM nybb;"
df = pd.concat(read_postgis(sql, con, chunksize=chunksize))
validate_boro_df(df)
# no crs defined on the created geodatabase, and none specified
# by user; should not be set to 0, as from get_srid failure
assert df.crs is None
def test_read_postgis_custom_geom_col(self, df_nybb):
con = connect("test_geopandas")
geom_col = "the_geom"
if con is None or not create_postgis(df_nybb, geom_col=geom_col):
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con, geom_col=geom_col)
finally:
con.close()
validate_boro_df(df)
def test_write_postgis_uppercase_tablename(self, engine_postgis, df_nybb):
"""Tests writing GeoDataFrame to PostGIS with uppercase tablename."""
engine = engine_postgis
table = "aTestTable"
# If table exists, delete it before trying to write with defaults
drop_table_if_exists(engine, table)
# Write to db
write_postgis(df_nybb, con=engine, name=table, if_exists="fail")
# Validate
sql = 'SELECT * FROM "{table}";'.format(table=table)
df = read_postgis(sql, engine, geom_col="geometry")
validate_boro_df(df)
def test_write_postgis_sqlalchemy_connection(self, engine_postgis, df_nybb):
"""Tests that GeoDataFrame can be written to PostGIS with defaults."""
with engine_postgis.begin() as con:
table = "nybb_con"
# If table exists, delete it before trying to write with defaults
drop_table_if_exists(con, table)
# Write to db
write_postgis(df_nybb, con=con, name=table, if_exists="fail")
# Validate
sql = "SELECT * FROM {table};".format(table=table)
df = read_postgis(sql, con, geom_col="geometry")
validate_boro_df(df)
def test_write_postgis_default(self, engine_postgis, df_nybb):
"""Tests that GeoDataFrame can be written to PostGIS with defaults."""
engine = engine_postgis
table = "nybb"
# If table exists, delete it before trying to write with defaults
drop_table_if_exists(engine, table)
# Write to db
write_postgis(df_nybb, con=engine, name=table, if_exists="fail")
# Validate
sql = "SELECT * FROM {table};".format(table=table)
df = read_postgis(sql, engine, geom_col="geometry")
validate_boro_df(df)
def test_from_postgis_custom_geom_col(self):
con = connect('test_geopandas')
if con is None or not create_db(self.df):
raise pytest.skip()
try:
sql = """SELECT
borocode, boroname, shape_leng, shape_area,
geom AS __geometry__
FROM nybb;"""
df = GeoDataFrame.from_postgis(sql, con, geom_col='__geometry__')
finally:
con.close()
validate_boro_df(df, case_sensitive=False)
def test_read_postgis_default(self, df_nybb):
con = connect("test_geopandas")
if con is None or not create_postgis(df_nybb):
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con)
finally:
con.close()
validate_boro_df(df)
# no crs defined on the created geodatabase, and none specified
# by user; should not be set to 0, as from get_srid failure
assert df.crs is None
def test_read_postgis_custom_geom_col(self):
con = connect('test_geopandas')
if con is None or not create_db(self.df):
raise unittest.case.SkipTest()
try:
sql = """SELECT
borocode, boroname, shape_leng, shape_area,
geom AS __geometry__
FROM nybb;"""
df = read_postgis(sql, con, geom_col='__geometry__')
finally:
con.close()
validate_boro_df(self, df)
def test_read_postgis_default(self):
con = connect('test_geopandas')
if con is None or not create_db(self.df):
raise unittest.case.SkipTest()
try:
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con)
finally:
if PANDAS_NEW_SQL_API:
# It's not really a connection, it's an engine
con = con.connect()
con.close()
validate_boro_df(self, df)
def test_read_postgis_default(self):
con = connect('test_geopandas')
if con is None or not create_postgis(self.df):
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con)
finally:
con.close()
validate_boro_df(df)
# no crs defined on the created geodatabase, and none specified
# by user; should not be set to 0, as from get_srid failure
assert df.crs is None
def test_read_postgis_binary(self, df_nybb):
"""Tests that geometry read as binary is accepted."""
try:
con = connect_spatialite()
except Exception:
raise pytest.skip()
else:
geom_col = df_nybb.geometry.name
create_spatialite(con, df_nybb)
sql = 'SELECT ogc_fid, borocode, boroname, shape_leng, shape_area, ST_AsBinary("{0}") AS "{0}" FROM nybb'.format(geom_col)
df = read_postgis(sql, con, geom_col=geom_col)
validate_boro_df(df)
finally:
if 'con' in locals():
con.close()
def test_read_postgis_default(self):
con = connect('test_geopandas')
if con is None or not create_db(self.df):
raise unittest.case.SkipTest()
try:
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con)
finally:
if PANDAS_NEW_SQL_API:
# It's not really a connection, it's an engine
con = con.connect()
con.close()
validate_boro_df(self, df)
def test_from_postgis_custom_geom_col(self):
con = connect('test_geopandas')
if con is None or not create_db(self.df):
raise pytest.skip()
try:
sql = """SELECT
borocode, boroname, shape_leng, shape_area,
geom AS __geometry__
FROM nybb;"""
df = GeoDataFrame.from_postgis(sql, con, geom_col='__geometry__')
finally:
con.close()
validate_boro_df(df, case_sensitive=False)
def test_read_postgis_select_geom_as(self, df_nybb):
"""Tests that a SELECT {geom} AS {some_other_geom} works."""
con = connect("test_geopandas")
orig_geom = "geom"
out_geom = "the_geom"
if con is None or not create_postgis(df_nybb, geom_col=orig_geom):
raise pytest.skip()
try:
sql = """SELECT borocode, boroname, shape_leng, shape_area,
{} as {} FROM nybb;""".format(orig_geom, out_geom)
df = read_postgis(sql, con, geom_col=out_geom)
finally:
con.close()
validate_boro_df(df)
def test_read_postgis_override_srid(self):
"""Tests that a user specified CRS overrides the geodatabase SRID."""
orig_crs = self.df.crs
created = create_postgis(self.df, srid=4269)
con = connect('test_geopandas')
if con is None or not created:
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con, crs=orig_crs)
finally:
con.close()
validate_boro_df(df)
assert(df.crs == orig_crs)
def test_read_postgis_select_geom_as(self):
"""Tests that a SELECT {geom} AS {some_other_geom} works."""
con = connect('test_geopandas')
orig_geom = "geom"
out_geom = "the_geom"
if con is None or not create_postgis(self.df, geom_col=orig_geom):
raise pytest.skip()
try:
sql = """SELECT borocode, boroname, shape_leng, shape_area,
{} as {} FROM nybb;""".format(orig_geom, out_geom)
df = read_postgis(sql, con, geom_col=out_geom)
finally:
con.close()
validate_boro_df(df)
def test_append_before_table_exists(self, engine_postgis, df_nybb):
"""
Tests that insert works with if_exists='append' when table does not exist yet.
"""
engine = engine_postgis
table = "nybb"
# If table exists, delete it before trying to write with defaults
drop_table_if_exists(engine, table)
write_postgis(df_nybb, con=engine, name=table, if_exists="append")
# Check that the row order matches
sql = "SELECT * FROM {table};".format(table=table)
df = read_postgis(sql, engine, geom_col="geometry")
validate_boro_df(df)
def test_read_postgis_override_srid(self, df_nybb):
"""Tests that a user specified CRS overrides the geodatabase SRID."""
orig_crs = df_nybb.crs
created = create_postgis(df_nybb, srid=4269)
con = connect("test_geopandas")
if con is None or not created:
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con, crs=orig_crs)
finally:
con.close()
validate_boro_df(df)
assert df.crs == orig_crs
def test_read_postgis_get_srid(self):
"""Tests that an SRID can be read from a geodatabase (GH #451)."""
crs = {"init": "epsg:4269"}
df_reproj = self.df.to_crs(crs)
created = create_postgis(df_reproj, srid=4269)
con = connect('test_geopandas')
if con is None or not created:
raise pytest.skip()
try:
sql = "SELECT * FROM nybb;"
df = read_postgis(sql, con)
finally:
con.close()
validate_boro_df(df)
assert(df.crs == crs)
def test_read_postgis_custom_geom_col(self):
con = connect('test_geopandas')
if con is None or not create_db(self.df):
raise unittest.case.SkipTest()
try:
sql = """SELECT
borocode, boroname, shape_leng, shape_area,
geom AS __geometry__
FROM nybb;"""
df = read_postgis(sql, con, geom_col='__geometry__')
finally:
if PANDAS_NEW_SQL_API:
# It's not really a connection, it's an engine
con = con.connect()
con.close()
validate_boro_df(self, df)
def test_read_file(self):
df = self.df.rename(columns=lambda x: x.lower())
validate_boro_df(self, df)
self.assert_(df.crs == self.crs)
