def test_rivers_by_station_number():
#test the type of the elements of the list
assert rivers_by_station_number(stations, 4)[1][0] == 'River Great Ouse'
#test the length of the list when N=9
assert len(rivers_by_station_number(stations, 9)) == 11
def test_rivers_station_number():
stations = build_station_list()
N = randint(0, 2000)
assert len(rivers_by_station_number(stations, N)) > 0
assert type(rivers_by_station_number(stations, N)) == list
for item in rivers_by_station_number(stations, N):
assert type(item[0]) == str
assert type(item[1]) == int
def test_rivers_by_station_number():
'''Test that the function works as required'''
stations = generate_test_station()
assert rivers_by_station_number(stations, 1) == [('River Y', 3)]
assert rivers_by_station_number(stations, 2) == [('River Y', 3),
('River X', 2),
('River Z', 2)
] or [('River Y', 3),
('River Z', 2),
('River X', 2)]
def run():
#Test sample of some station
stations = build_station_list()
# Running the function to get a list called result
result = rivers_by_station_number(stations,6)
# Printing the result
print(result)
def run():
"""Requrement for Task 1E"""
stations = build_station_list()
first_N_rivers = rivers_by_station_number(stations, 9)
print(first_N_rivers)
def rivers_by_station_number():
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]
N = 2
output_list = geo.rivers_by_station_number(stations, N)
assert len(output_list) == 3
for i in range(1, len(output_list)):
assert output_list[i][1] >= output_list[i - 1][1]
def run():
"""Requirements for Task 1E"""
# Build list of stations
stations = build_station_list()
list_of_rivers_numbers = rivers_by_station_number(stations, 9)
print("Rivers with greatest number of stations: {}".format(
list_of_rivers_numbers))
def run():
"""Requirements for Task 1E"""
# Build list of stations
stations = build_station_list()
N = 6
x = rivers_by_station_number(stations, N)
print(x)
def test_rivers_by_station_number():
# make a station list
station_list = stationdata.build_station_list()
for N in [5, 10, 20]:
rivers = geo.rivers_by_station_number(station_list, N)
assert (len(rivers) >= N)
if len(rivers) > N:
# check for a true tie condition
tie_val = rivers[N - 1][1]
for river in rivers[N:]:
assert (river[1] == tie_val)
# check that all tied rivers were returned
rivers_one_more = geo.rivers_by_station_number(station_list, len(rivers) + 1)
assert (rivers_one_more[-1][1] < tie_val)
def run():
#builds list of stations
stations = stationdata.build_station_list(use_cache=True)
#gets rivers with the 9 most stations
top_rivers = geo.rivers_by_station_number(stations, 9)
print(top_rivers)
def test_rivers_by_station_number():
stations = build_station_list()
#try for 6 days
N=6
x=rivers_by_station_number(stations,N)
assert len(x)>=N
for a in x:
#check that elements of list are tuples
assert type(a)==tuple
def test_rivers_by_station_number():
stations = build_station_list()
tuple_list = rivers_by_station_number(stations, 50)
assert isinstance(tuple_list, list) == True
assert isinstance(tuple_list[0], tuple) == True
i = 0
for i in range(len(tuple_list) - 1):
assert tuple_list[i][1] >= tuple_list[i + 1][1]
assert len(tuple_list) == 60
def run():
'''
Test for function: rivers_by_station_number
'''
stations = build_station_list()
output = rivers_by_station_number(stations, 12)
print(output)
return output
def run():
"""Requirements for Task 1D"""
# Build list of stations
stations = build_station_list()
test_case_1=rivers_by_station_number(stations,N=10)
print(test_case_1)
def run():
"""Requirement for Task 1E"""
stations = build_station_list()
# Build dictionary relating rivers (key) to stations (value)
maxstationlist = rivers_by_station_number(stations,10)
print(maxstationlist)
def run():
#build station list
stations = build_station_list()
#N=int(input('Enter a number of rivers' ))
N = 9
#runs function
print(rivers_by_station_number(stations, N))
def run():
"""Requirements for Task 1E"""
print("*** Task 1E: CUED Part IA Flood Warning System ***")
#Build list of stations
stations = build_station_list()
print(
"Top 12 rivers by number of stations, and all other rivers with equal number of stations:"
)
print(rivers_by_station_number(stations, 12))
def run():
"""Requirements for Task 1E"""
# Build list of stations
stations = build_station_list()
# Get the top 9 rivers by station number
by_station_number = rivers_by_station_number(stations, 9)
# When testing, this only gives 9 rivers, as the current list of stations differs from the original list.
# N=10 gives 11 items.
print(by_station_number)
def test_rivers_by_station_number():
#Initialise variables
stations = build_station_list()
N = 9
first_N_rivers = geo.rivers_by_station_number(stations, N)
#River with expected greatest number of stations
test_river = "Thames"
#Checks that at least as many stations that are called for are returned
if len(first_N_rivers) < N:
raise ValueError(
"First {} rivers called for but only {} returned".format(
N, len(first_N_rivers)))
#Checks if test river has the greatest number of stations
if first_N_rivers[0][0] != test_river:
raise ValueError(
"{} does not have the greatest number of staions - data may be incomplete"
.format(test_river))
def test_rivers_by_station_number():
N = 9
result = rivers_by_station_number(stations, N)
assert len(result) >= 9
if len(result) == N:
for n in range(len(result) - 1):
x = result[n]
y = result[n + 1]
assert x[1] >= y[1]
elif len(result) > N:
for n in range(N - 1):
x = result[n]
y = result[n + 1]
assert x[1] >= y[1]
for n in range(N, len(result) - 1):
x = result[n]
y = result[n + 1]
assert x == y
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 test_rivers_by_station_number():
s_id = "test-s-id"
m_id = "test-m-id"
label = "Station 1"
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 = "Station 2"
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)
s_id = "test-s-id3"
m_id = "test-m-id3"
label = "Station 3"
coord = (-2.0, 4.0)
trange = (-2.3, 3.4445)
river = "River X"
town = "My Town"
u = 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)
Example_build_list.append(u)
a = rivers_by_station_number(Example_build_list, 1)
assert a == [('River X', 2)]
def test_rivers_by_station_number_returns_a_list_of_river_names_with_the_number_of_stations_in_each(
):
stations = []
rivers = ["A", "B", "C", "A", "B", "D", "E", "B", "A", "C", "B", "D"]
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_by_station_number = geo.rivers_by_station_number(stations, 3)
expected_rivers_by_station_number = [("B", 4), ("A", 3), ("C", 2),
("D", 2)]
print(actual_rivers_by_station_number)
assert actual_rivers_by_station_number == expected_rivers_by_station_number
from floodsystem.geo import stations_by_river
from floodsystem.flood import stations_level_over_threshold
stations = build_station_list()
update_water_levels(stations)
severe = []
high = []
moderate = []
low = []
'''If river has is in top 20 rivers in terms of how many stations
it has on it, the station severity will be increased by one level for
otherwise moderate and high levels due to potential risk of stations on
that river being flooded as well'''
top_twenty = rivers_by_station_number(stations, 20)
for station in stations:
river = str(station.river)
for i in top_twenty:
if i[0] == river:
in_top_twenty = True
else:
in_top_twenty = False
station_level = station.relative_water_level()
if station_level != 0:
if station.typical_range_consistent() == True:
if station.latest_level is not None:
if station_level > 1.5:
def test_geo_5():
stations = build_station_list()
assert rivers_by_station_number(stations, 12)[0] == ('River Thames', 55)
assert len(rivers_by_station_number(stations, 800)) != 800
def test_rivers_by_station_number():
g = rivers_by_station_number(stations, 9)
assert type(g) == list
for i in g:
assert type(i) == tuple
def run():
stations = build_station_list()
print(rivers_by_station_number(stations, 9))
def test_rivers_by_station_number():
stations = build_station_list()
x = rivers_by_station_number(stations, 10)
assert ('Thames', 55) in x
def run():
# Put code here that demonstrates functionality
print (rivers_by_station_number(stations, 9))
def test_rivers_by_staion_number():
# Build a list of staions
stations = build_station_list()
ans = geo.rivers_by_station_number(stations, 9)
assert len(ans) >= 9
