def test_rivers_with_station(): # Build list of stations stations = build_station_list() ans = geo.rivers_with_station(stations) assert len(ans) == len(set(ans)) # All elements should be unique
def run(): '''Requrements for Task 1D''' # Builds Stations List stations = build_station_list() # Compiles a list of rivers. prints the length and first ten riversWithStation = rivers_with_station(stations) print(len(riversWithStation)) sortedList = sorted(riversWithStation) print(sortedList[:10]) # Compiles a list of stations sorted by river and prints a list of stations on three rivers in particular stationsByRiver = stations_by_river(stations) riverAire = list() riverCam = list() riverThames = list() for station in stationsByRiver['River Aire']: riverAire.append(station.name) riverAire.sort() for station in stationsByRiver['River Cam']: riverCam.append(station.name) riverCam.sort() for station in stationsByRiver['River Thames']: riverThames.append(station.name) riverThames.sort() print(riverAire, '\n', riverCam, '\n', riverThames)
def run(): #builds a list of stations stations = stationdata.build_station_list(use_cache=True) #builds a list of rivers that have at least one monitoring station rivers = geo.rivers_with_station(stations) #builds a dictionary of rivers matched with their monitoring stations rivers_stations = geo.stations_by_river(stations) #counts the number of rivers that have at least one monitoring station number_rivers = len(rivers) print(number_rivers) #orders the list of rivers with monitoring stations alphabetically order_rivers = sorted(rivers) #creates an empty list rivers_first = list() #adds the first 10 rivers alphabetically to the empty list for i in range(0, 10): rivers_first.append(order_rivers[i]) print(rivers_first) #returns the monitoring stations for River Aire in alphabetical order river_aire = rivers_stations["River Aire"] print("RIVER AIRE:", sorted(river_aire)) #returns the monitoring stations for River Cam in alphabetical order river_cam = rivers_stations["River Cam"] print("RIVER CAM:", sorted(river_cam)) #returns the monitoring stations for River Thames in alphabetical order river_thames = rivers_stations["River Thames"] print("RIVER THAMES", sorted(river_thames))
def test_geo_3(): stations = build_station_list() rivers_with_station_list = sorted(rivers_with_station(stations)) assert rivers_with_station_list[0] == 'Addlestone Bourne' for i in range(100, 200): assert rivers_with_station_list[i] != rivers_with_station_list[i + 1]
def test_rivers_with_station(): # Create a station s_id = "test-s-id" m_id = "test-m-id" label = "some station" coord = (-2.0, 4.0) trange = (-2.3, 3.4445) river = "River X" town = "My Town" s = MonitoringStation(s_id, m_id, label, coord, trange, river, town) s_id = "test-s-id2" m_id = "test-m-id2" label = "A station" coord = (2.0, -4.05) trange = (-2.3, 3.4445) river = "River Y" town = "My Town B" t = MonitoringStation(s_id, m_id, label, coord, trange, river, town) #Build an empty list for storing tuples later Example_build_list = [] Example_build_list.append(s) Example_build_list.append(t) k = rivers_with_station(Example_build_list) assert len(k) == 2
def run(): """Requirements for Task 1D""" print("*** Task 1D: CUED Part IA Flood Warning System ***") #Build list of stations stations = build_station_list() rivers_with_station_list = rivers_with_station(stations) # Count number of unique rivers print("Number of unique rivers:") print(len(rivers_with_station_list)) #List the first ten alphabetically print("First ten rivers alphabetically:") print(rivers_with_station_list[:10]) #List the stations on the specified rivers stations_by_river_dict = stations_by_river(stations) print("Stations on the River Aire:") print(stations_by_river_dict['River Aire']) print("Stations on the River Cam:") print(stations_by_river_dict['River Cam']) print("Stations on the River Thames:") print(stations_by_river_dict['River Thames'])
def run(): stations = build_station_list() """ Part 1 of Task 1D """ a = rivers_with_station(stations) """ Sorting the list of rivers """ b = sorted(a) print(len(a), '\n') """Getting the first 10 entries """ print(b[:10], '\n') """ Part 2 of Task 1D """ riverdict = stations_by_rivers(stations) c = riverdict["River Aire"] d = riverdict["River Cam"] e = riverdict["Thames"] print(sorted(c), '\n') print(sorted(d), '\n') print(sorted(e))
def run(): #build station list stations = build_station_list() #creates sorted set of rivers monitored rivers_monitored = rivers_with_station(stations) #prints the first 10 entries in the set print("\n", "First 10 stations with Monitoring Stations:") for i in range(10): print(rivers_monitored[i]) #generates dictionary stations_by_river_dict = stations_by_river(stations) #prints dictionary entries for 3 rivers print("\n", "Stations on the River Aire:") riveraire = stations_by_river_dict['River Aire'] for i in riveraire: print(i) print("\n", "Stations on the River Cam:") rivercam = stations_by_river_dict['River Cam'] for i in rivercam: print(i) print("\n", "Stations on the Thames:") thames = stations_by_river_dict['Thames'] for i in thames: print(i)
def run(): """Requrement for Task 1D""" stations = build_station_list() rivers=rivers_with_station(stations) def test_first_x_rivers_with_station(x): """Calls the <<rivers_with_station>> function and prints the total number of rivers and the first x rivers with a station""" #Prints the total number of rivers print("Total rivers with stations: {}\n".format(str(len(rivers)))) #Converts the set into a sorted list rivers_in_order=sorted(rivers) #Creates empty list of first x rivers test_rivers=[] #Adds first x rivers to list for river in rivers_in_order[:x]: test_rivers.append(river) print("First {} rivers with stations: {}\n".format(x, test_rivers)) def test_stations_by_river(rivers): """Calls the <<stations_by_river>> function and prints a list of stations for each river in a list""" stationsbyriver=stations_by_river(stations) for river in rivers: #Calls list of stations on a river test_stations=stationsbyriver.get(river) #Sorts list of stations stations_in_order=sorted(test_stations) print("Stations on {}: {}\n".format(river, stations_in_order)) test_first_x_rivers_with_station(10) test_stations_by_river(["River Aire", "River Cam", "Thames"])
def test_river_with_station(): # builds stations and list of rivers s_id = "test-s-id" m_id = "test-m-id" label = "some station" coord = (6.0, 4.0) trange = None river = "River X" town = "My Town" s = MonitoringStation(s_id, m_id, label, coord, trange, river, town) river = "River X" s1 = MonitoringStation(s_id, m_id, label, coord, trange, river, town) river = "River Y" s2 = MonitoringStation(s_id, m_id, label, coord, trange, river, town) river = "River Y" s3 = MonitoringStation(s_id, m_id, label, coord, trange, river, town) river = "River Z" s4 = MonitoringStation(s_id, m_id, label, coord, trange, river, town) stations = [s, s1, s2, s3, s4] rivers = geo.rivers_with_station(stations) #Makes sure that data processing is valid assert rivers is not None assert len(rivers) == 3 assert "River X" in rivers assert "River Y" in rivers assert "River Z" in rivers
def test_rivers_with_station(): stations = build_station_list() l = rivers_with_station(stations) assert type(l) == list for item in l: assert type(item) == str
def test_rivers_with_station(): stations = build_station_list() riverswithstation=rivers_with_station(stations) #check that there are no duplicates assert len(riverswithstation)==len(set(riverswithstation)) #check that it is a list assert isinstance(riverswithstation,list) #check that it returns demonstration prog result assert riverswithstation[:1]==['Addlestone Bourne']
def test_rivers_with_station(): stations = build_station_list() r = rivers_with_station(stations) assert len(r) == 857 for i in stations: for j in r: a = 0 if i.river == j: a = a + 1 assert a >= 1
def run(): """1st Requirement for Task 1D""" stations = build_station_list() # Build set of rivers rivers = rivers_with_station(stations) sorted_rivers = sorted(rivers) print("First 10 rivers in alphabetical order:", sorted_rivers[:10]) # print print("\n") print("Number of rivers with at least one station:", len(rivers))
def run(): # Build list of stations stations = build_station_list() rivers = rivers_with_station(stations) d = stations_by_river(stations) print(rivers[:10]) print(d['River Aire']) print(d['River Cam']) print(d['Thames'])
def run(): stations = build_station_list() rivers = rivers_with_station(stations) print("Number of rivers: {}".format(len(rivers))) print("First ten rivers: {}".format(sorted(rivers)[:10])) rivers_dict = stations_by_river(stations) test_rivers = ("River Aire", "River Cam", "River Thames") for river in test_rivers: stations_on_river = rivers_dict.get(river) station_names = [s.name for s in stations_on_river] print("Stations on {}: {}".format(river, station_names))
def run(): """Requirements for Task 1D""" # Build list of stations stations = build_station_list() riverswithstation = rivers_with_station(stations) print(len(riverswithstation)) riverswithstation = (riverswithstation) print(riverswithstation[:10]) stationsbyriver = stations_by_river(stations) print(stationsbyriver["River Thames"])
def test_rivers_with_station(): #Initialise variables stations = build_station_list() rivers = geo.rivers_with_station(stations) test_river = "River Cam" if len(rivers) < 100: raise ValueError( "Less than 100 rivers in set - data may be incomplete") #Checks of test_river is present in list of rivers if test_river not in rivers: raise ValueError( "{} not present - data may be incomplete".format(test_river))
def run(): stations = build_station_list() rivers = rivers_with_station(stations) rivers_sorted = sorted(rivers) print(rivers_sorted[:10]) print() dict = stations_by_river(stations) check_rivers = ['River Aire', 'River Cam', 'River Thames'] for check_river in check_rivers: list1 = dict[check_river] station_names = [x.name for x in list1] station_names = sorted(station_names) print(station_names)
def run(): """Requirements for Task 1D""" # Build list of stations stations = build_station_list() # Sort the stations by distance from cambridge centre rivers = rivers_with_station(stations) # Print the first 10 rivers print("{} stations. First 10 - {}".format(len(rivers), sorted(rivers)[:10])) # Get the dictionary of stations by river by_rivers = stations_by_river(stations) # Print the 3 entries print(sorted([station.name for station in by_rivers["River Aire"]])) print(sorted([station.name for station in by_rivers["River Cam"]])) print(sorted([station.name for station in by_rivers["River Thames"]]))
def test_rivers_with_station_returns_all_rivers(): stations = [] rivers = ["A", "B", "C", "A", "B", "D", "E"] for i in range(len(rivers)): # Create stations s_id = "test-s-id-" + str(i) m_id = "test-m-id-" + str(i) label = "some station " + str(i) coord = (0.0, 0.0) trange = (-2.3, 3.4445) river = rivers[i] town = "My Town " + str(i) stations.append( MonitoringStation(s_id, m_id, label, coord, trange, river, town)) actual_rivers = geo.rivers_with_station(stations) expected_rivers = {"A", "B", "C", "D", "E"} assert actual_rivers == expected_rivers
def run(): """ * Print how many rivers have at least one monitoring station * Prints the first 10 of these rivers in alphabetical order * Print the names of the stations located on the following rivers in alphabetical order: - 'River Aire' - 'River Cam' - 'River Thames' """ stations = build_station_list() rivers = rivers_with_station(stations) print(len(rivers)) print(sorted(rivers)[:10]) print() stations_on_river = stations_by_river(stations) for river in ['River Aire', 'River Cam', 'River Thames']: print(river + ':') print(sorted([i.name for i in stations_on_river[river]]))
def test_rivers_by_station_number(): stations = build_station_list() l = rivers_with_station(stations) N = len(l) output = rivers_by_station_number(stations, N) assert type(output) == list for t in output: assert type(t) == tuple assert len(t) == 2 assert type(t[0]) == str assert type(t[1]) == int # Check if list of river tuples is in descending order list_of_lists = [] # Convert list of tuples to list of lists list_of_lists.append(list(t)) for n in range(len(list_of_lists) - 1): assert list_of_lists[n][1] <= list_of_lists[n + 1][1]
def run(): """Requirements for Task1D""" # Build a list of stations stations = build_station_list() # Get a list of rivers with stations RiverWithStation = list(geo.rivers_with_station(stations)) RiverWithStation.sort() # Get first 10 print(RiverWithStation[:10]) # Get a dict of river->stations on this river RiverByStation = geo.stations_by_river(stations) # Get required things RiverByStation['River Aire'].sort() print(RiverByStation['River Aire']) RiverByStation['River Cam'].sort() print(RiverByStation['River Cam']) RiverByStation['Thames'].sort() print(RiverByStation['Thames'])
from floodsystem.geo import rivers_with_station from floodsystem.geo import stations_on_rivers from floodsystem.stationdata import build_station_list stations = build_station_list() """rivers have at least one monitoring station""" set_of_rivers = rivers_with_station(stations) list_of_rivers = list(set_of_rivers) """prints the first 10 of these rivers in alphabetical order""" print(sorted(list_of_rivers)[:10]) """dictionary that maps river names to a list of stations on a given river""" dictionary_of_rivers = stations_on_rivers(set_of_rivers, stations) """print the names of the stations located on some rivers in alphabetical order""" print(sorted(dictionary_of_rivers['River Aire'])) print(sorted(dictionary_of_rivers['River Cam'])) print(sorted(dictionary_of_rivers['Thames']))
for i in unique_labels: if i != -1: # not noise for coord in X[labels == i]: location_map3.circle(x=coord[1], y=coord[0], size=10, color=cluster_pallet[i], fill_alpha=0.8) label_to_stations[i].append(coord_to_station[(coord[0], coord[1])]) # find the station from its coordinates and append it to the dictionary location_map3.plot_width = 700 location_map3.plot_height = 500 location_map3.sizing_mode = 'scale_width' # Risky rivers warning_text2 = Div( text="""<p><b>{}</b> rivers with stations at risk, the top 5 is tabulated below.</p>""".format( len(rivers_with_station(risky_stations))), width=600 ) warning_text2.sizing_mode = 'scale_width' risky_rivers = rivers_by_station_number(risky_stations, 5) risky_rivers_source = ColumnDataSource( data=dict(name=[i[0] for i in risky_rivers], num=[i[1] for i in risky_rivers]) ) risky_river_table_columns = [ TableColumn(field="name", title="River Name"), TableColumn(field="num", title="Number of Risky Stations"), ] risky_river_table = DataTable(source=risky_rivers_source, columns=risky_river_table_columns, width=500, height=140) risky_river_table.sizing_mode = 'scale_width'
def test_rivers_with_station(): """Test that the function returns the correct data without duplicates""" stations = generate_test_station() assert rivers_with_station(stations) == {"River X", "River Y", "River Z"}
from floodsystem.geo import rivers_with_station from floodsystem.geo import stations_by_river from floodsystem.stationdata import build_station_list stations = build_station_list() list_of_all_rivers = sorted(rivers_with_station(stations)) print(len(list_of_all_rivers)) print(list_of_all_rivers[0:10]) dic_of_rivers = stations_by_river() riv = str(input("What is the river?")) print(sorted(dic_of_rivers[riv])) "River Aire, River Cam, Thames"
def test_rivers_with_station(): stations = build_station_list() x = rivers_with_station(stations) sorted_stations = sorted(x) assert 'Adur' in sorted_stations
def test_rivers_with_station(): b = rivers_with_station(stations) for i in range(len(b)): assert type(b[i]) == str assert len(b) > 0