Upload 5 files

<h1>Postcodes Map</h1>

<h2>Project Overview</h2>
The Postcodes Map is a Python-based interactive visualization tool that leverages Folium for mapping and Gradio for creating an intuitive web interface. <br>
This tool is designed to help users visualize the distribution and frequency of postcodes across specific UK regions, providing insights into geographical data trends.

<h2>Features</h2>
<li>Interactive Mapping: Utilizes Folium to create dynamic maps that display geographical data based on UK postcodes.
<li>Frequency Visualization: Generates heatmaps to indicate the frequency of postcodes, distinguishing between areas with varying densities.
<li>File Upload Capability: Allows users to upload their postcode data in CSV or Excel formats directly through a web interface.
<li>Customizable Visuals: Supports different heatmap intensities and colors based on data frequency, enhancing the analytical utility of the maps.

<h2>License</h2>
This project is licensed under the MIT License.

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/ukpostcodes.csv filter=lfs diff=lfs merge=lfs -text

data/ukpostcodes.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39890648ae7165babb23192da09a48704f1ebc9250494fee77e3f78f6d0b0501
+size 65741556

gradio/app.py

@@ -0,0 +1,83 @@
+import gradio as gr
+from folium.plugins import HeatMap
+from ingest import load_data
+from process import get_lat_lon
+from gradio_folium import Folium
+from folium import Map
+
+
+def update_header(file_info):
+    if file_info is not None:
+        filename = file_info.split('/')[-1]  # Access the filename from the file_info dictionary
+        header = f"<h1>Nordic Balance Postcodes Map: {filename}</h1>"  # Update the Markdown content
+    return header  # Continue to pass the file_info to the next function if necessary
+
+def generate_map(file_path):
+    # Load the postcodes
+    postcode_mapping = load_data('../data/ukpostcodes.csv')
+    # Load the data (this needs to be adapted to work outside Flask)
+    postcodes = load_data(file_path)
+
+    # Get latitude, longitude, and count data for the specified postcodes
+    lat_lon_data = get_lat_lon(postcodes, postcode_mapping)
+
+    # Prepare data for different frequency bands
+    low_freq_data = [
+        [data['latitude'], data['longitude']] 
+        for data in lat_lon_data 
+        if data['count'] == 1 and data['latitude'] and data['longitude']
+    ]
+    med_freq_data = [
+        [data['latitude'], data['longitude']] 
+        for data in lat_lon_data 
+        if 2 <= data['count'] <= 5 and data['latitude'] and data['longitude']
+    ]
+    high_freq_data = [
+        [data['latitude'], data['longitude']] 
+        for data in lat_lon_data 
+        if data['count'] > 5 and data['latitude'] and data['longitude']
+    ]
+
+    # Create your map here using Folium
+    map = Map(location=[51.505303, -0.13902], zoom_start=10)
+
+    # Adding different heatmaps for different frequencies
+    if low_freq_data:
+        HeatMap(low_freq_data, radius=10, blur=10, gradient={0.8: 'blue', 1: 'lime'}).add_to(map)
+    if med_freq_data:
+        HeatMap(med_freq_data, radius=15, blur=10, gradient={0.8: 'orange', 1: 'lime'}).add_to(map)
+    if high_freq_data:
+        HeatMap(high_freq_data, radius=20, blur=10, gradient={0.8: 'red', 1: 'lime'}).add_to(map)
+    
+    return map 
+
+# Define a Gradio interface
+with gr.Blocks() as demo:
+
+    with gr.Row(): 
+        header = gr.Markdown(("<h1>Nordic Balance Postcodes Map</h1>"))
+    
+    with gr.Row():
+        map = Folium(value = Map(location=[51.505303, -0.13902], zoom_start=10), height=750)
+
+
+    with gr.Row():
+        file_uploader = gr.UploadButton(
+            label=("Upload"),
+            file_count="single",
+            file_types=[".csv", ".xlsx", '.xls'],
+            interactive=True,
+            scale=1,
+        )
+
+    file_uploader.upload(fn = generate_map, 
+                        inputs= file_uploader, 
+                        outputs=map)
+    
+    file_uploader.upload(fn=update_header, 
+                         inputs=file_uploader, 
+                         outputs=header)
+
+                    
+if __name__ == "__main__":
+    demo.launch()

gradio/ingest.py

@@ -0,0 +1,15 @@
+import pandas as pd
+
+def load_data(filepath):
+    # Check the file extension and load the file accordingly
+    if filepath.endswith('.csv'):
+        df = pd.read_csv(filepath)
+    elif filepath.endswith('.xlsx') or filepath.endswith('.xls'):
+        df = pd.read_excel(filepath)
+    else:
+        raise ValueError("Unsupported file format: Please provide a .csv or .xlsx file")
+    
+    # Convert all string values to lowercase and remove spaces
+    df = df.map(lambda x: x.lower().replace(" ", "") if isinstance(x, str) else x)
+    
+    return df

gradio/process.py

@@ -0,0 +1,32 @@
+import pandas as pd
+import gradio as gr
+
+
+def get_lat_lon(postcodes_df, postcode_mapping):
+
+    try:
+    
+        postcode_mapping.rename(columns={'postcode': 'Postal code'}, inplace=True)
+
+        # Normalize postcodes to ensure matching and count occurrences
+        postcodes_df['Postal code'] = postcodes_df['Postal code'].str.lower().str.replace(' ', '')
+        postcode_counts = postcodes_df['Postal code'].value_counts().reset_index()
+        postcode_counts.columns = ['Postal code', 'count']
+        
+        # Normalize the postcodes in the mapping DataFrame
+        postcode_mapping['Postal code'] = postcode_mapping['Postal code'].str.lower().str.replace(' ', '')
+        
+        # Merge the counts with the mapping data
+        result_df = pd.merge(postcode_counts, postcode_mapping, on='Postal code', how='left')
+        
+        # Fill NaN values for latitude and longitude where postcode was not found in the mapping
+        result_df['latitude'] = result_df['latitude'].fillna('')
+        result_df['longitude'] = result_df['longitude'].fillna('')
+        
+        # Optionally, convert the DataFrame to a dictionary if needed, or work directly with the DataFrame
+        results = result_df.to_dict(orient='records')
+    
+    except: 
+        raise gr.Error('Make sure your file contains the postal codes under a column named "Postal code"')
+    
+    return results

gradio/requirements.txt

@@ -0,0 +1,4 @@
+pandas==2.2.2
+openpyxl==3.1.2
+gradio==4.27.0
+gradio_folium==0.0.6