def run():
"""Requirement for Task 2E"""
#Initialise variables
data = build_station_list()
update_water_levels(data)
ls = []
ID = []
#Number of days in past taken data from
dt = 7
#How many graphs per window
limit = 4
#How many stations
number = 6
#Create list of measuring_id's sorted by water level
for station in data:
if station.typical_range_consistent(
) == True and station.relative_water_level() != None:
ls.append((station, station.relative_water_level()))
ls = sorted_by_key(ls, 1)
for station in ls:
ID.append(station[0])
s = count_inconsistent_sets(ID[:number], dt)
ID = ID[:number + s]
plot_water_levels(ID, dt, limit, s)
def run():
#Requirements for Task2E
n = 6
dt = 10
stations = build_station_list()
update_water_levels(stations)
#build list of tuples of stations
b_tuples = stations_highest_rel_level(stations, n)
#Let"s convert the list of tuples into a list of stations!
b = []
for station in stations: #maybe change the order of these two functions?
for station_tuple in b_tuples:
if station.name == station_tuple[0]:
b.append(station)
break
print(b)
# plot data for each station
for station in b:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
if len(dates) == 0 or len(levels) == 0:
continue # Test for the stations with incorrect datafetcher responses
plot_water_levels(station, dates, levels)
plt.show()
def run():
# Build list of stations
stations = build_station_list()
# Update latest level data for all stations
update_water_levels(stations)
#create list of names stations to be plotted with their measure_id
highest_levels=stations_highest_rel_level(stations, 5)
stations_to_plot = []
#retrieve the rest of station data for the high
for j in highest_levels:
for i in stations:
if j[0] == i.name:
stations_to_plot.append(i)
dt = 10
#plot data for each station
for i in stations_to_plot:
dates, levels = fetch_measure_levels(i.measure_id,
dt=timedelta(days=dt))
plot_water_levels(i.name,dates,levels)
plt.show()
def run():
#get the stations data and sorted by latest water level
stations = build_station_list()
#get the six stations with the largest water level
highest_six = stations_highest_rel_level(stations, 6)
#set the length of time for wanted water level
dt = 10
#plotting water level against time of those six stations
i = 0
station_name = []
date_and_level = []
for station in highest_six:
dates, levels = fetch_measure_levels(station.measure_id, dt=datetime.timedelta(days=dt))
plt.subplots()
plot_water_levels(station, dates, levels)
station_name.append(station.name)
date_and_level.append((dates, levels))
i += 1
plt.show()
print(station_name)
return station_name, date_and_level
def run():
# Build list of stations
stations = build_station_list()
N = 5
update_water_levels(stations)
list_of_5_stations_greatest_level = stations_highest_rel_level(stations, N)
dt = 10
for station in list_of_5_stations_greatest_level:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
plot_water_levels(station, dates, levels)
def run():
stations = build_station_list()
update_water_levels(stations)
stations_relative = stations_highest_rel_level(stations, 5)
dt = 10
for station in stations_relative:
dates, levels = fetch_measure_levels(station.measure_id,
datetime.timedelta(days=dt))
plot_water_levels(station, dates, levels)
def run():
# Build list of stations
stations = build_station_list()
update_water_levels(stations)
# Fetch data over past 2 days
dt = 10
x=stations_highest_rel_level(stations,5)
for station, ratio in x:
dates, levels = fetch_measure_levels(
station.measure_id, dt=datetime.timedelta(days=dt))
print(station.name)
plot_water_levels(station, dates, levels)
def run():
stations = build_station_list()
dt = 10
update_water_levels(stations)
greatest_relative_level_stations = stations_highest_rel_level(stations, 5)
for station in greatest_relative_level_stations:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
plot_water_levels(station, dates, levels)
plt.show()
def run():
# Build list of stations
stations = build_station_list()
update_water_levels(stations)
stations_at_risk = stations_highest_rel_level(stations, 5)
print(stations_at_risk)
# Fetch data over past 10 days
dt = 10
for station in stations_at_risk:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
plot_water_levels(station, dates, levels)
def test_plot_water_levels():
stations = build_station_list()
update_water_levels(stations)
dt = 10
x = random.randrange(0, len(stations) - 1, 1)
y = random.randrange(0, len(stations) - 1, 1)
#check whether function actually plots anyting or not
for i in [x, y]:
station = stations[i]
dates, levels = fetch_measure_levels(station.measure_id,
datetime.timedelta(days=dt))
plot_water_levels(station, dates, levels)
def run():
stations = stationdata.build_station_list()
stationdata.update_water_levels(stations)
stations = station.consistant_typical_range_stations(stations)
top5Stations = flood.stations_highest_rel_level(stations, 5)
top5StationsDates = []
top5StationsLevels = []
for top5station in top5Stations:
stationDates, stationLevels = datafetcher.fetch_measure_levels(
top5station.measure_id, timedelta(days=10))
top5StationsDates.append(stationDates)
top5StationsLevels.append(stationLevels)
plot.plot_water_levels(top5Stations, top5StationsDates, top5StationsLevels)
def run():
"""Requirements for Task 2E"""
# Build a list of the top 5 stations by current water level
stations = build_station_list()
update_water_levels(stations)
top_5_stations = sorted(
[s for s in stations if s.latest_level is not None],
key=lambda x: x.latest_level,
reverse=True)[:5]
# Plot the station levels against time for those stations, for the past 10 days
dt = datetime.timedelta(days=10)
for station in top_5_stations:
dates, levels = fetch_measure_levels(station.measure_id, dt)
plt.plot_water_levels(station, dates, levels)
def test_plot_water_levels():
# Tests checks if plot is built for 'River Cam'
# Does not check graph for accuracy
stations = build_station_list()
update_water_levels(stations)
for station in stations:
if station.name == 'Cam':
station_cam = station
break
dt = 10
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
plot_water_levels(station_cam, dates, levels)
assert "Graphs displayed"
def run():
"""Requirements for Task2E"""
# Build list of stations
stations = build_station_list()
update_water_levels(stations)
shortlist = flood.stations_highest_rel_level(stations, 5)
dt = 10
for station in shortlist:
for target in stations:
if target.name == station.name:
dates, levels = datafetcher.fetch_measure_levels(target.measure_id,
dt=datetime.timedelta(days=dt))
plot.plot_water_levels(target, dates, levels)
break
def run():
# Build list of stations
stations = build_station_list()
# Update latest level data for all stations
update_water_levels(stations)
#Initiate empty list
levellist = []
#initiate temperory storage for water level data for error processing
templevel = 0
# iterate for all stations
for station in stations:
templevel = station.latest_level
# Change NonType to zero for data analysis
if templevel == None:
templevel = 0
# Change negative error data to zero
if templevel < 0:
templevel = 0
# append to a list
levellist.append((station.name,templevel))
# Sorted after iteration
levellist = sorted_by_key(levellist,1)
# get the greatest five station
levellist = levellist[-5:]
# Get the name of the 5 stations (first entry of the tumple)
stationname = []
for llist in levellist:
stationname.append(llist[0])
print(stationname)
for station_name in stationname:
station_temp = None
for station in stations:
if station.name == station_name:
station_temp = station
break
dt = 10
dates, levels = fetch_measure_levels(station_temp.measure_id, dt=datetime.timedelta(days=dt))
plot_water_levels(station_name, dates, levels)
def run():
# get 5 stations with highest relative level
days_to_plot = 10
stations_list = build_station_list()
at_risk_stations = stations_highest_rel_level(stations_list, 5)
# create input list
argv = []
for station in at_risk_stations:
# get tuple of dates and corresponding levels in the last days
data = fetch_measure_levels(station.measure_id,
dt=timedelta(days=days_to_plot))
# append station, dates, and levels to the input list
argv.append(station)
argv.append(data[0])
argv.append(data[1])
# plot water levels and typical highs/lows
plot_water_levels(argv)
def run():
# Build list of stations
stations = build_station_list()
update_water_levels(stations)
station_and_relative_water_levels = []
for station in stations:
station_and_relative_water_levels.append(
(station.relative_water_level(), station.name, station))
stations_with_values_for_water_levels = []
for x in station_and_relative_water_levels:
if x[0] is None:
pass
else:
stations_with_values_for_water_levels.append(x)
stations_with_values_for_water_levels.sort(reverse=True)
"""for n in stations_with_values_for_water_levels:
dt = 10
dates, levels = fetch_measure_levels(n[2].measure_id,
dt=datetime.timedelta(days=dt))
print(dates[0], dates [-1])
print(dates[0]-dates[-1])
if dates[0]-dates[-1] != dt-1:
#cut n from list"""
"""find a way to automate removal stations with outdated data
"""
greatest_5 = stations_with_values_for_water_levels[1:6]
#Fetch data over past 10 days
for n in greatest_5:
dt = 10
dates, levels = fetch_measure_levels(n[2].measure_id,
dt=datetime.timedelta(days=dt))
print(dates[0], dates[-1])
#plot graph
plot_water_levels(n[2], dates, levels)
def test_plot_water_levels_does_not_crash_if_levels_and_dates_are_not_the_same_length(
):
# 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"
station = MonitoringStation(s_id, m_id, label, coord, trange, river, town)
dates = [
dt(2025, 4, 3, 2, 1, 0),
dt(2025, 4, 3, 2, 1, 1),
dt(2025, 4, 3, 2, 1, 2),
dt(2025, 4, 3, 2, 1, 3),
dt(2025, 4, 3, 2, 1, 4)
]
levels = [0, 1, 2, 3, 4, 5]
plot_water_levels(station, dates, levels)
def run():
# Build list of stations
stations = build_station_list()
# Station name to find
station_name = "Cam"
# Find station
station_cam = None
for station in stations:
if station.name == station_name:
station_cam = station
break
# Check that station could be found. Return if not found.
if not station_cam:
print("Station {} could not be found".format(station_name))
return
# Alternative find station 'Cam' using the Python 'next' function
# (https://docs.python.org/3/library/functions.html#next). Raises
# an exception if station is not found.
# try:
# station_cam = next(s for s in stations if s.name == station_name)
# except StopIteration:
# print("Station {} could not be found".format(station_name))
# return
# Fetch data over past 2 days
dt = 2
dates, levels = fetch_measure_levels(
station_cam.measure_id, dt=datetime.timedelta(days=dt))
# Print level history
for date, level in zip(dates, levels):
print(date, level)
plot_water_levels(station_cam, dates, levels)
def run():
dates = (datetime.datetime(2017, 2, 24), datetime.datetime(2017, 3, 3))
# Build list of stations
stations = build_station_list()
# Compiles list of 5 most at risk stations
list_of_stations = [0] * 5
for i in range(5):
list_of_stations[i] = stations_highest_rel_level(stations, 5)[i][0]
return plot_water_levels(list_of_stations, dates)
def run():
# Build list of stations
stations = build_station_list()
update_water_levels(stations)
dt=10
names=[name for name,level in stations_level_over_threshold(stations,0.8)]
print(names)
for i in range(6):
for station in stations:
if station.name == names[i]:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
print(plot_water_levels(station,dates,levels,i))
plt.show()
from floodsystem.stationdata import build_station_list, update_water_levels
from floodsystem.flood import stations_highest_rel_level
from floodsystem.datafetcher import fetch_measure_levels
from floodsystem.plot import plot_water_levels
import datetime
stations = build_station_list()
update_water_levels(stations)
names = stations_highest_rel_level(stations, 5)
print(names)
list_names = []
for name in names:
list_names.append(name[0])
print(list_names)
for station in stations:
if station.name in list_names:
dt = 10
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
if len(dates) == 0:
print("NO AVAILABLE DATA for:", station.name)
elif len(levels) == 0:
print("NO AVAILABLE DATA for:", station.name)
else:
plot_water_levels(station, dates, levels)
print(station.typical_range, station.latest_level)
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 28 16:01:54 2017
@author: user
"""
import datetime
from floodsystem.stationdata import build_station_list, update_water_levels
from floodsystem.datafetcher import fetch_measure_levels
from floodsystem.plot import plot_water_levels
from floodsystem.flood import stations_highest_rel_level
stations = build_station_list()
update_water_levels(stations)
#Getting the 5 stations with the highest water level
at_risk = stations_highest_rel_level(stations, 5)
dt = 10
#Finding dates and levels data for the 5 stations and plotting them
for item in at_risk:
for station in stations:
if station.name == item[0]:
dates, levels = fetch_measure_levels(
station.measure_id, dt=datetime.timedelta(days=dt))
plot_water_levels(station.name, dates, levels)
import matplotlib.pyplot as plt
from datetime import datetime, timedelta, date, time
from floodsystem.datafetcher import fetch_measure_levels
from floodsystem.stationdata import build_station_list
from floodsystem.plot import plot_water_levels
from floodsystem.flood import stations_level_over_threshold
stations = build_station_list()
a = stations_level_over_threshold(stations, 0.8)
x = a[:5]
m = []
for i in range(0, 5):
m.append(x[i][0])
print(m)
for i in stations:
for k in m:
if k == i.name:
dates, levels = fetch_measure_levels(i.measure_id,
dt=timedelta(days=10))
plot_water_levels(i, dates, levels)
from floodsystem.stationdata import build_station_list
from floodsystem.stationdata import update_water_levels
from floodsystem.utils import sorted_by_key
from floodsystem.datafetcher import fetch_measure_levels
import datetime
from floodsystem.plot import plot_water_levels
from floodsystem.plot import plot_water_level_with_fit
from floodsystem.analysis import polyfit
from floodsystem.flood import stations_highest_rel_level
stations = build_station_list(use_cache=False)
update_water_levels(stations)
highest_stations = stations_highest_rel_level(stations, 5)
'''
for i in highest:
highest_stations.append(i[1])
'''
for i in highest_stations:
station_name = i[0]
station_0 = None
for station in stations:
if station.name == station_name:
station_0 = station
break
dt = 10
dates0, levs0 = fetch_measure_levels(station_0.measure_id,
dt=datetime.timedelta(days=dt))
plot_water_levels(station_0, dates0, levs0)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Feb 24 18:04:58 2018
@author: fai
"""
from datetime import datetime, timedelta
from floodsystem.plot import plot_water_levels
from floodsystem.stationdata import build_station_list
stations = build_station_list()
t = [
datetime(2016, 12, 30),
datetime(2016, 12, 31),
datetime(2017, 1, 1),
datetime(2017, 1, 2),
datetime(2017, 1, 3),
datetime(2017, 1, 4),
datetime(2017, 1, 5)
]
level = [0.2, 0.7, 0.95, 0.92, 1.02, 0.91, 0.64]
station = stations[0]
plot_water_levels(station, t, level)
def test_plot_water_levels():
stations = build_station_list()
station = stations[0]
assert plot_water_levels(station, [0, 1, 2, 3, 4],
[10, 20, 30, 40, 50]) == "No Error"
