def test_join_to_location_column_names(exemplar_level_param): """ Test that JoinToLocation's column_names property is accurate.""" if "cell" == exemplar_level_param["level"]: pytest.skip("Cell level not valid for JoinToLocation" ) # cell level not valid for JoinToLocation table = subscriber_locations("2016-01-05", "2016-01-07", level="cell") joined = JoinToLocation(table, **exemplar_level_param) assert joined.head(0).columns.tolist() == joined.column_names
def test_join_to_location_column_names(exemplar_spatial_unit_param): """ Test that JoinToLocation's column_names property is accurate.""" if not exemplar_spatial_unit_param.has_geography: pytest.skip("JoinToLocation does not accept CellSpatialUnit objects") table = SubscriberLocations("2016-01-05", "2016-01-07", spatial_unit=make_spatial_unit("cell")) joined = JoinToLocation(table, spatial_unit=exemplar_spatial_unit_param) assert joined.head(0).columns.tolist() == joined.column_names
def test_join_to_grid(get_dataframe, get_length): """ Test that we can join to a grid square """ ul = subscriber_locations("2016-01-05", "2016-01-07", level="cell") df = get_dataframe(JoinToLocation(ul, level="grid", size=50)) assert len(df) == get_length(ul)
def test_join_to_grid(self): """ Test that we can join to a grid square """ df = JoinToLocation(self.ul, level="grid", size=50).get_dataframe() self.assertEqual(len(df), len(self.ul))
def test_join_with_versioned_cells(get_dataframe, get_length): """ Test that flowmachine.JoinToLocation can fetch the cell version. """ ul = SubscriberLocations( "2016-01-05", "2016-01-07", spatial_unit=make_spatial_unit("cell") ) df = get_dataframe( JoinToLocation(ul, spatial_unit=make_spatial_unit("versioned-cell")) ) # As our database is complete we should not drop any rows assert len(df) == get_length(ul) # These should all be version zero, these are the towers before the changeover date, or those that # have not moved. should_be_version_zero = df[ (df.time <= move_date) | (~df.location_id.isin(moving_sites)) ] # These should all be one, they are the ones after the change over time that have moved. should_be_version_one = df[ (df.time > move_date) & (df.location_id.isin(moving_sites)) ] assert (should_be_version_zero.version == 0).all() assert (should_be_version_one.version == 1).all()
def test_join_to_admin(get_dataframe, get_length): """ Test that flowmachine.JoinToLocation can join to a admin region. """ ul = subscriber_locations("2016-01-05", "2016-01-07", level="cell") df = get_dataframe(JoinToLocation(ul, level="admin3")) assert len(df) == get_length(ul) expected_cols = sorted(["subscriber", "time", "location_id", "pcod"]) assert sorted(df.columns) == expected_cols
def test_join_to_admin(self): """ Test that flowmachine.JoinToLocation can join to a admin region. """ df = JoinToLocation(self.ul, level="admin3").get_dataframe() self.assertEqual(len(df), len(self.ul)) expected_cols = sorted(["subscriber", "time", "location_id", "name"]) self.assertEqual(sorted(df.columns), expected_cols)
def test_join_to_location_raises_value_error(): """ Test that JoinToLocation raises an InvalidSpatialUnitError if spatial_unit does not have geography information. """ with pytest.raises(InvalidSpatialUnitError): table = SubscriberLocations("2016-01-05", "2016-01-07", spatial_unit=make_spatial_unit("cell")) joined = JoinToLocation(table, spatial_unit=make_spatial_unit("cell"))
def test_join_to_location_no_cache_if_joinee_no_cache(): with pytest.raises(NotImplementedError): table = SubscriberLocations("2016-01-05", "2016-01-07", spatial_unit=make_spatial_unit("admin", level=3)) joined = JoinToLocation(table, spatial_unit=make_spatial_unit("admin", level=3)) joined.fully_qualified_table_name
def test_join_to_grid(get_dataframe, get_length): """ Test that we can join to a grid square """ ul = SubscriberLocations("2016-01-05", "2016-01-07", spatial_unit=make_spatial_unit("cell")) df = get_dataframe( JoinToLocation(ul, spatial_unit=make_spatial_unit("grid", size=50))) assert len(df) == get_length(ul)
def test_join_with_polygon(self): """ Test that flowmachine.JoinToLocation can get the (arbitrary) polygon of each cell. """ try: make_fake_table(self.con) j = JoinToLocation( self.ul, level="polygon", column_name="naame", polygon_table="test_geog.ad3", geom_col="geo", ) df = j.get_dataframe() finally: drop_fake_table(self.con) self.assertIs(type(df), DataFrame) expected_cols = sorted(["subscriber", "time", "location_id", "naame"]) self.assertEqual(sorted(df.columns), expected_cols) self.assertEqual(len(df), len(self.ul))
def test_join_with_polygon(get_dataframe, get_length): """ Test that flowmachine.JoinToLocation can get the (arbitrary) polygon of each cell. """ ul = subscriber_locations("2016-01-05", "2016-01-07", level="cell") j = JoinToLocation( ul, level="polygon", column_name="admin3pcod", polygon_table="geography.admin3", geom_col="geom", ) df = get_dataframe(j) expected_cols = sorted(["admin3pcod", "location_id", "subscriber", "time"]) assert sorted(df.columns) == expected_cols assert len(df) == get_length(ul)
def test_join_with_versioned_cells(self): """ Test that flowmachine.JoinToLocation can fetch the cell version. """ df = JoinToLocation(self.ul, level="versioned-cell").get_dataframe() # As our database is complete we should not drop any rows self.assertEqual(len(df), len(self.ul)) # These should all be version zero, these are the towers before the changeover date, or those that # have not moved. should_be_version_zero = df[(df.time <= self.move_date) | (~df.location_id.isin(self.moving_sites))] # These should all be one, they are the ones after the change over time that have moved. should_be_version_one = df[(df.time > self.move_date) & (df.location_id.isin(self.moving_sites))] self.assertTrue((should_be_version_zero.version == 0).all()) self.assertTrue((should_be_version_one.version == 1).all())
def test_join_with_lat_lon(get_dataframe): """ Test that flowmachine.JoinToLocation can get the lat-lon values of the cell """ ul = subscriber_locations("2016-01-05", "2016-01-07", level="cell") df = get_dataframe(JoinToLocation(ul, level="lat-lon")) expected_cols = sorted(["subscriber", "time", "location_id", "lat", "lon"]) assert sorted(df.columns) == expected_cols # Pick out one cell that moves location and assert that the # lat-lons are right focal_cell = "dJb0Wd" lat1, long1 = (27.648837800000003, 83.09284486) lat2, long2 = (27.661443318109132, 83.25769074752517) post_move = df[(df.time > move_date) & (df["location_id"] == focal_cell)] pre_move = df[(df.time < move_date) & (df["location_id"] == focal_cell)] # And check them all one-by-one np.isclose(pre_move.lat, lat1).all() np.isclose(pre_move.lon, long1).all() np.isclose(post_move.lat, lat2).all() np.isclose(post_move.lon, long2).all()
def test_join_with_lon_lat(get_dataframe): """ Test that flowmachine.JoinToLocation can get the lon-lat values of the cell """ ul = SubscriberLocations( "2016-01-05", "2016-01-07", spatial_unit=make_spatial_unit("cell") ) df = get_dataframe(JoinToLocation(ul, spatial_unit=make_spatial_unit("lon-lat"))) expected_cols = sorted(["subscriber", "time", "location_id", "lon", "lat"]) assert sorted(df.columns) == expected_cols # Pick out one cell that moves location and assert that the # lon-lats are right focal_cell = "dJb0Wd" lon1, lat1 = (83.09284486, 27.648837800000003) lon2, lat2 = (83.25769074752517, 27.661443318109132) post_move = df[(df.time > move_date) & (df["location_id"] == focal_cell)] pre_move = df[(df.time < move_date) & (df["location_id"] == focal_cell)] # And check them all one-by-one np.isclose(pre_move.lon, lon1).all() np.isclose(pre_move.lat, lat1).all() np.isclose(post_move.lon, lon2).all() np.isclose(post_move.lat, lat2).all()
def test_join_with_lat_lon(self): """ Test that flowmachine.JoinToLocation can get the lat-lon values of the cell """ df = JoinToLocation(self.ul, level="lat-lon").get_dataframe() self.assertIs(type(df), DataFrame) expected_cols = sorted( ["subscriber", "time", "location_id", "lat", "lon"]) self.assertEqual(sorted(df.columns), expected_cols) # Pick out one cell that moves location and assert that the # lat-lons are right focal_cell = "dJb0Wd" lat1, long1 = (27.648837800000003, 83.09284486) lat2, long2 = (27.661443318109132, 83.25769074752517) post_move = df[(df.time > self.move_date) & (df["location_id"] == focal_cell)] pre_move = df[(df.time < self.move_date) & (df["location_id"] == focal_cell)] # And check them all one-by-one np.isclose(pre_move.lat, lat1).all() np.isclose(pre_move.lon, long1).all() np.isclose(post_move.lat, lat2).all() np.isclose(post_move.lon, long2).all()