Feedback

.github/workflows/pythonapp.yml

@@ -25,7 +25,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install  flake8 matplotlib pytest requests
+          pip install  flake8 matplotlib pytest requests haversine mock
 
       - name: Lint with flake8
         run: flake8 --statistics *.py

.gitlab-ci.yml

@@ -2,18 +2,18 @@ image: python:3.7
 
 test:
   script:
-  # Install Python packages required to run code. Add any additional
-  # packages your code needs require here.
-  - pip install dateutils flake8 matplotlib numpy pytest requests
+    # Install Python packages required to run code. Add any additional
+    # packages your code needs require here.
+    - pip install dateutils flake8 matplotlib numpy pytest requests mock
 
-  # flake8 static code and style testing. Enable for extra testing.
-  # - python -m flake8 .
+    # flake8 static code and style testing. Enable for extra testing.
+    # - python -m flake8 .
 
     # Run unit tests
-  - python -m pytest -v .
+    - python -m pytest -v .
 
-  # Run deliverables. Add your deliverables to the test system here.
-  - python Task1A.py
+    # Run deliverables. Add your deliverables to the test system here.
+    - python Task1A.py
 
-  - python Task2A.py
-  - python Task2D.py
+    - python Task2A.py
+    - python Task2D.py

Help-Guide.rtf

@@ -0,0 +1,60 @@
+{\rtf1\ansi\ansicpg1252\cocoartf2577
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fnil\fcharset0 Menlo-Regular;}
+{\colortbl;\red255\green255\blue255;\red0\green0\blue0;\red255\green255\blue255;\red27\green31\blue34;
+\red10\green77\blue204;\red249\green250\blue251;}
+{\*\expandedcolortbl;;\cssrgb\c0\c0\c0;\cssrgb\c100000\c100000\c100000;\cssrgb\c14118\c16078\c18039;
+\cssrgb\c1176\c40000\c83922;\cssrgb\c98039\c98431\c98824;}
+\paperw11900\paperh16840\margl1440\margr1440\vieww11520\viewh8400\viewkind0
+\pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural\partightenfactor0
+
+\f0\fs28 \cf2 \cb3 CUED Flood Warning System:\
+\
+Creating SSH Key: (Recommended but not mandatory)\
+\
+1. Check for existing SSH Keys - \
+\pard\pardeftab720\partightenfactor0
+\cf2 \expnd0\expndtw0\kerning0
+ls -al ~/.ssh\
+# Lists the files in your .ssh directory, if they exist\
+\
+2. \
+ssh-keygen -t ed25519 -C "your_email@example.com"\
+\
+3. Changing Passphrase\
+ssh-keygen -p -f ~/.ssh/id_ed25519\
+\
+Git:\
+\
+1. Use source control to manage commits, messages and pushing to repo.\
+\
+2. To push change:\
+\
+ - Head to source control \
+ - View proposed change\
+ - Click on \'91stage change\'92 icon\
+ - Add commit message\
+ - Click check mark to commit (to local file system)\
+ - Click (\'85) to view further options and select push (sends to remote team repo.)\
+\
+Linting:\
+\
+1. Open terminal: pip install pylint (\'97-user) \
+\
+2. Open command palette on VSCode\
+\
+3. Type - Python: Select Linter\
+\
+4. Choose flake8 (a wrapper which checks code for adherence to flake8 coding style)\
+\
+\
+5. GitHub Build Log (under Actions) shows potential errors with commits to repo including stylistic errors. \
+\
+6. Please use clear messages when committing to repo for benefit of other team members.\
+\
+7. Commit - Saves to local file system. \
+   Push - Pushes changes to GitHub remote repo. ({\field{\*\fldinst{HYPERLINK "https://github.com/cued-ia-computing/flood-jzo20-lk480"}}{\fldrslt \cf5 \cb6 flood-jzo20-lk480}}\cf4 \cb1 )
+\fs27\fsmilli13600 \cf2 \cb3 \
+\
+\
+\
+}

Task1B.py

@@ -0,0 +1,19 @@
+from floodsystem.stationdata import build_station_list
+from floodsystem.geo import stations_by_distance
+
+
+def run():
+
+    station = build_station_list()
+    list_of_stations = stations_by_distance(station, (52.2053, 0.1218))
+    ten_closest_stations = [(station.name, station.town, distance) for station, distance in list_of_stations[:10]]
+    ten_furthest_stations = [(station.name, station.town, distance) for station, distance in list_of_stations[-10:]]
+    print(f"10 closest stations from cambridge \n: {ten_closest_stations}")
+    print(f"10 furthest stations from cambridge \n: {ten_furthest_stations}")
+
+
+if __name__ == "__main__":
+    print("*** Task 1B: CUED Part IA Flood Warning System ***")
+    run()
+
+my_variable = 8

Task1C.py

@@ -0,0 +1,18 @@
+from floodsystem.stationdata import build_station_list
+from floodsystem.geo import stations_within_radius
+
+
+def run():
+
+    stations = build_station_list()
+    centre_coord = (52.2053, 0.1218)
+    r = 10
+    list_of_stations = stations_within_radius(stations, centre_coord, r)
+    print("All stations within {rad}km from {centre}\n: {ans}".format(rad=r, centre=centre_coord, ans=list_of_stations))
+
+
+if __name__ == "__main__":
+    print("*** Task 1C: CUED Part IA Flood Warning System ***")
+    run()
+
+my_variable = 8

Task1D.py

@@ -0,0 +1,39 @@
+from floodsystem.stationdata import build_station_list
+from floodsystem.geo import rivers_with_station
+from floodsystem.geo import stations_by_river
+
+
+def run():
+    # Build the MoniteringStation list
+    stations = build_station_list()
+
+    # Part 1, first 10 river with at least one station
+    num_station_atleast_one = rivers_with_station(stations)
+    first_ten = num_station_atleast_one[:10]
+    # printing the length and first 10
+    print('{} stations. First 10 - {}'.format(len(num_station_atleast_one), first_ten))
+
+    # Part 2
+    Obj_around_river = stations_by_river(stations)
+    Aire = sorted(Obj_around_river['River Aire'])
+    Cam = sorted(Obj_around_river['River Cam'])
+    Thames = sorted(Obj_around_river['River Thames'])
+    print('River Aire stations: {}\n River Cam stations: {}\n River Thames stations: {}\n'.format(Aire, Cam, Thames))
+
+    # Without getting a dictionary
+    # for river in ["River Aire", "River Cam", "River Thames"]:
+    #    station_list = []
+
+    #    for station in stations_by_river(stations)[river]: (couldn't work)
+
+    #    for station in stations: (but this works)
+    #        if river == station.river:
+    #            station_list.append(station.name)
+    #    print(sorted(station_list))
+
+
+if __name__ == "__main__":
+    print("*** Task 1D: CUED Part IA Flood Warning System ***")
+    run()
+
+my_variable = 8

Task1E.py

@@ -0,0 +1,14 @@
+from floodsystem.stationdata import build_station_list
+from floodsystem.geo import rivers_by_station_number
+
+
+def run():
+    N = 9  # As stated in demonstration program requirements
+    stations = build_station_list()
+    result = rivers_by_station_number(stations, N)
+    print(f"List of {N} rivers with the greatest number of monitoring stations \n {result}")
+
+
+if __name__ == "__main__":
+    print("*** Task 1E: CUED Part IA Flood Warning System ***")
+    run()

Task1F.py

@@ -0,0 +1,13 @@
+from floodsystem.stationdata import build_station_list
+from floodsystem.station import inconsistent_typical_range_stations
+
+
+def run():
+    stations = build_station_list()
+    result = inconsistent_typical_range_stations(stations)
+    print(f"List of stations with inconsistent typical range data \n {result}")
+
+
+if __name__ == "__main__":
+    print("*** Task 1F: CUED Part IA Flood Warning System ***")
+    run()

Task2B.py

@@ -0,0 +1,21 @@
+from floodsystem.stationdata import build_station_list, update_water_levels
+from floodsystem.flood import stations_level_over_threshold
+
+
+def run():
+    # Build list of stations
+    stations = build_station_list()
+
+    # Update latest level data for all stations
+    update_water_levels(stations)
+
+    # Obtain list of stations with relative level over given threshold
+    result = stations_level_over_threshold(stations, 0.8)
+
+    for station, relative_level in result:
+        print(f"{station.name}: {relative_level}")
+
+
+if __name__ == "__main__":
+    print("*** Task 2B: CUED Part IA Flood Warning System ***")
+    run()

Task2C.py

@@ -0,0 +1,21 @@
+from floodsystem.stationdata import build_station_list, update_water_levels
+from floodsystem.flood import stations_highest_rel_level
+
+
+def run():
+    # Build list of stations
+    stations = build_station_list()
+
+    # Update latest level data for all stations
+    update_water_levels(stations)
+
+    # Obtain list of stations with highest relative water level
+    result = stations_highest_rel_level(stations, 10)
+
+    for station, relative_level in result:
+        print(f"{station.name}: {relative_level}")
+
+
+if __name__ == "__main__":
+    print("*** Task 2C: CUED Part IA Flood Warning System ***")
+    run()

Task2E.py

@@ -0,0 +1,20 @@
+from floodsystem.stationdata import build_station_list, get_historical_water_levels
+from floodsystem.plot import plot_water_levels, plot_water_levels_bokeh
+
+
+def run(plot_type):
+    # Build list of stations
+    stations = build_station_list()
+    station = stations[0]
+    dates, levels = get_historical_water_levels(station, 10)
+    if plot_type == "matplotlib":
+        plot_water_levels(station, dates, levels)
+    elif plot_type == "bokeh":
+        plot_water_levels_bokeh(station, dates, levels)
+    else:
+        raise Exception(f"Unknown Plot Type {plot_type}")
+
+
+if __name__ == "__main__":
+    print("*** Task 2E: CUED Part IA Flood Warning System ***")
+    run("matplotlib")

Task2F.py

@@ -0,0 +1,20 @@
+from floodsystem.stationdata import build_station_list, update_water_levels, get_historical_water_levels
+from floodsystem.plot import plot_water_level_with_fit
+from floodsystem.flood import stations_highest_rel_level
+
+
+def run():
+    # Build list of stations
+    stations = build_station_list()
+    # Update latest level data for all stations
+    update_water_levels(stations)
+
+    stations_highest_level = stations_highest_rel_level(stations, 5)
+    for station, _ in stations_highest_level:
+        dates, levels = get_historical_water_levels(station, 2)
+        plot_water_level_with_fit(station, dates, levels, 4)
+
+
+if __name__ == "__main__":
+    print("*** Task 2F: CUED Part IA Flood Warning System ***")
+    run()

Task2G.md

@@ -0,0 +1,17 @@
+# Flood Warning System Flood Risk Assesment Methodology 
+
+This file outline the assesment methodology for determining the flood risk at towns across the UK.
+
+Polynomial Regression:
+To generate a regression line to forecast future water levels we utilised numpy polyfit.
+The numpy.poly1d object allows us to obtain the latest water level according to the polynimal regression
+line on the day we have specified. 
+
+The polynomial is generated by using a least-squares regression on a set period of historical data. After 
+experimenting with different lookback periods, 30 days gave us the most accurate forecast and hence is the default argument to the function. 
+
+Assesment:
+To classify the towns for flood risk we utilised the relative water level to compare the latest forecasted level to
+the typical high/low range data for each station. We then sorted the stations by the town they were situated in and selected the largest relative water level. 
+
+We then utilised a conditional statement to classify the risk level depending on the magnitude of the relative water level. Thus obtaining a flood risk assesment for all towns in the DEFRA. 

Task2G.py

@@ -0,0 +1,77 @@
+from datetime import date
+from collections import defaultdict
+from floodsystem.stationdata import build_station_list, update_water_levels
+from floodsystem.analysis import update_forecasted_levels
+from floodsystem.flood import stations_highest_rel_level
+
+# Please see classification methodology .md file
+
+SEVERE = 2.0
+HIGH = 1.0
+MODERATE = 0.5
+LOW = 0.0
+
+
+def risk_assesment(relative_water_levels):
+    """Takes a list of relative water levels by station for each town, computes the
+    largest relative water level.
+    If largest relative water level is greater than [2.0,] returns Severe.
+    If largest relative water level is between than [1.0, 2.0), returns High.
+    If largest relative water level is between than [0.5, 1.0), returns Moderate.
+    If largest relative water level is greater than [, 0.5), returns Severe.
+    Args:
+        relative_water_levels ([list]): List of relative water levels
+    Returns:
+        [str]: Flood Risk Assesment
+    """
+    max_relative_water_level = max([x for x in relative_water_levels if x is not None])
+    if max_relative_water_level >= SEVERE:
+        return 'Severe'
+    elif HIGH <= max_relative_water_level < SEVERE:
+        return 'High'
+    elif MODERATE <= max_relative_water_level < HIGH:
+        return 'Moderate'
+    else:
+        return 'Low'
+
+
+def run(forecast_date, N=50):
+    # 1. Build list of all Monitoring Stations
+    all_stations = build_station_list()
+    # 2. Update latest water levels for each station
+    update_water_levels(all_stations)
+    # 3. Find N stations with highest latest water level
+    stations_rel_level = stations_highest_rel_level(all_stations, N)
+    # 4. Unpack list of station objects
+    stations = [station for station, _ in stations_rel_level]
+    # 5. Forecast level for given date and update the latest-level for each station
+    update_forecasted_levels(stations, forecast_date)
+    # 6. Create default dictionary with values of an empty list
+    relative_levels_by_town = defaultdict(list)
+
+    # 7. Populating relative_levels_town with relative water level for each station in a town
+    for station in stations:
+        # Exclude stations where the town name is not provided
+        if station.town is not None:
+            v = relative_levels_by_town[station.town]
+            v.append(station.relative_water_level())
+
+    # 8. Create dictionary to store flood warning by town
+    flood_warning_by_town = {}
+
+    # 9. Populate dictionary by calling risk_assesment() function with a list of forecasted
+    # relative water levels.
+    for town, relative_water_levels in relative_levels_by_town.items():
+        flood_warning_by_town[town] = risk_assesment(relative_water_levels)
+
+    # 10. Return dictionary of flood warning by town
+    return flood_warning_by_town
+
+
+if __name__ == "__main__":
+    print("*** Task 2G: CUED Part IA Flood Warning System ***")
+    forecast_date = date(2021, 3, 5)
+    number_of_stations = 50
+    flood_warning_by_town = run(forecast_date, number_of_stations)
+    for k, v in flood_warning_by_town.items():
+        print(f"{k}: {v}")