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"