data folder

.gitattributes

@@ -29,3 +29,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zstandard filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+historicalData filter=lfs diff=lfs merge=lfs -text
+historicalData/ filter=lfs diff=lfs merge=lfs -text

.streamlit/config.toml

@@ -0,0 +1,29 @@
+[server]
+
+port = 8501
+
+headless = true
+
+
+[browser]
+
+# Internet address where users should point their browsers in order to connect to the app. Can be IP address or DNS name and path.
+# This is used to: - Set the correct URL for CORS and XSRF protection purposes. - Show the URL on the terminal - Open the browser
+# Default: 'localhost'
+serverAddress = "localhost"
+
+# Whether to send usage statistics to Streamlit.
+# Default: true
+gatherUsageStats = true
+
+# Port where users should point their browsers in order to connect to the app.
+# This is used to: - Set the correct URL for CORS and XSRF protection purposes. - Show the URL on the terminal - Open the browser
+# Default: whatever value is set in server.port.
+serverPort = 8501
+
+
+
+[theme]
+
+# The preset Streamlit theme that your custom theme inherits from. One of "light" or "dark".
+base = "light"

.streamlit/secrets.toml

@@ -0,0 +1,13 @@
+
+
+[gcp_service_account]
+type = "data-visualizationproject"
+project_id = "fe5615839c19ff35f46a8262eaa0cc48e5a21193"
+private_key_id = "fe5615839c19ff35f46a8262eaa0cc48e5a21193"
+private_key = "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDKI+L0Ll9Rz2C/\n5Kban6SlVYtmfZZPZlHyZSU4FzrIKj1YuBW96LHgPM1b00jGRaRizK+tVqnY0+8W\nWAdJnCPDZBoeSnFdcKlGvCQSxxGuWkJWhOc9IdxK1Rk4ckgJD2kU3JLta/fzqJhl\n8dyNE42x6Wch+O9LCSiHhjzfCKnTjNwkR6cstQFxklwydYPa44F4K4AgOwsz0vBf\nDHYr8c9bwaXJOx8ZhZ+VgzLy5HFbENyN/9rXug+B1nWS5WRnBPyYhlNKLPFVf0Dy\nmTksOkISse3H2jljSl+1HM8mehnLF7GPq2sAwd+LMnT4AKIjjFPz/2vcjaJJmTt8\nXY5w9Q1BAgMBAAECggEAAsLv3rq7swEakvKJaEEQMXFIS86VSSlGXzGsKw6PrzR7\nBTFSHDefpvbjrhCGTO2egdpGn99IR5nZGUC7fEEjoK+nVvC4yOBRMrH/KunA60Uo\nxPhwtYZG9XeA7kNK6kNFcetTv0Y3Y2LzLojZ5Mw+pj6gWd+mCrwRu3y9LAWY9tau\neYcOHtoPn8Y0qVqe1M/NXDuJrIg7zNk763T/6pRTUu12f6K4l3iVJch7Qx0WVAMV\ni+FXmikLXgdkpk2P/NZrKCOyzBdNOjVVH0wE4iIZt5P2PS/rRKjGJZRDZg/NBRzJ\n5WWO8fNhTwhMkAlwIzjOd3BkUNO5XUdCEFqyW66WQQKBgQD+39Fz6A6OdW20zjXL\nEldqorIaJ59Tjfpv3JmD18eG5UsuIgj4GdSawqRtqgulYmVJp5z8XQDih3i4+0uD\n2pjXxetm6gRsQEWfklMCez+PgxQ7pBzbi5W4p2s104006e9P6aXQqkApjP8XLjzV\nREbbPGGEfLwipwjdNECZUEJIYQKBgQDLCHFeWH0RMGkU9WecNZxSAyCtqrfARhoM\nC08m2LKhLDwNAeYwmBkQlduhWtUPfqxOxL/WmP2Kq/tJ6ZXl8DjkT2craae5EP2P\nrsIma8m4dgJuveJfO2UlnwJvZTQs5+6RGKQFBjonP2qT90OLfZZfZUE5ZH0377sk\ngkMIf6lw4QKBgQCvqrAARScTRRhyD9a/ukqJ8szyffCwdCDyTId6eZTKAuvIRikM\nZzFD4XfXJeaU/LZ3B5GJ1sgvWdP5Gyq3HElQHtfavNyDh+D01LNl+HCch2nAmaJS\nJ2jwNmQMW1zt5XbOC2n/4fgLK2T+Ix5Gl6KGpJ1J5Xb+I0ZWwBbuFIU6wQKBgHTj\n6Hkb0u1phKYnXz5k8xmYaWDyz5WoBmj2vdwsmDMIh44pkMBbYNrWnDr6U333PPag\neZ3wONB0kVkNXVqjge2X9VreGk0HBiSJxYdfOSS09FOTiNexF1ugf0No7bAI26W3\nnP6zhhmAfjiv+7g8Vq2XWwTS4PCqWYD8aeFjtkahAoGBANyoPpnY1h1qFmMtwKI5\nIlAxNBZjDOzbVeE8lSnJgVnSdeqiGPrrm85UYNgpuss+yfdhcPSTql9/k7ido0x3\nEZmPErHU9pff+fYjLTJoiS3tx/bY8F1EdFI+9KwkDJJgzFClWwXkH1LnO0f4xvvk\nWS7uakfu/xsYJ/WhBAFZn8Jo\n-----END PRIVATE KEY-----\n"
+client_email ="pooja-yadav-2012@data-visualizationproject.iam.gserviceaccount.com"
+client_id = "117601902564876434051"
+auth_uri =  "https://accounts.google.com/o/oauth2/auth"
+token_uri = "https://oauth2.googleapis.com/token"
+auth_provider_x509_cert_url = "https://www.googleapis.com/oauth2/v1/certs"
+client_x509_cert_url = "https://www.googleapis.com/robot/v1/metadata/x509/pooja-yadav-2012%40data-visualizationproject.iam.gserviceaccount.com"

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.9.12
+
+WORKDIR /ethio_hydro
+
+# Upgrade pip and install requirements
+
+COPY requirements.txt requirements.txt
+RUN pip install -U pip
+RUN pip install -r requirements.txt
+
+# Expose port you want your app on
+EXPOSE 8501
+
+# Copy app code and set working directory
+COPY app.py app.py
+COPY references references
+COPY stlib stlib
+COPY precipitation_function.py  precipitation_function.py
+COPY temperature_functions.py   temperature_functions.py
+COPY .streamlit .streamlit
+
+
+
+# Run
+RUN pip install streamlit
+ENTRYPOINT ["streamlit", "run", "app.py"]

app.py

@@ -0,0 +1,42 @@
+#standard imports
+import pandas as pd
+import streamlit as st
+from PIL import Image
+
+
+
+# Setting the Page Layout as wide
+
+st.set_page_config(
+    page_title="AI GERD Dashboard",
+    layout="wide")
+
+# # Creating Container for Logo and Title
+with st.container():
+    col1,col2 = st.columns(2)
+    #Code for adding Logo
+    with col1:
+        image = Image.open('references/image.png')
+        st.image(image)
+    #Code for Title
+    with col2:
+        col2.markdown("<h1 style='text-align:centre; color: black;'>ETHIO HYDRO & CLIMATE HUB</h1>", unsafe_allow_html=True)
+
+message = """
+            __Select an application from the list below__
+            """
+
+from stlib import precipitation
+from stlib import temperature
+
+
+with st.sidebar:
+    st.markdown(message)
+    page = st.selectbox(' ',['Temperature',"Precipitation"])
+
+
+if page == 'Temperature':
+    temperature.run()
+
+elif page == 'Precipitation':
+    precipitation.run()

app.yaml

@@ -0,0 +1,12 @@
+runtime: custom
+env: flex
+# entrypoint: find ${VIRTUAL_ENV}/lib/python3.9/site-packages/streamlit -type f \( -iname \*.py -o -iname \*.js \) -print0 | xargs -0 sed -i 's/healthz/health-check/g' && streamlit run sim_v3.py --server.port $PORT --server.enableCORS=false
+
+# runtime_config:
+#   python_version: 3
+#
+# manual_scaling:
+#   instances: 1
+#
+# network:
+#   session_affinity: true

docker-compose.yml

@@ -0,0 +1,9 @@
+version: "3.7"
+services:
+    streamlit:
+        build:
+          context: streamlit/
+        volumes:
+          - ./streamlit:/app
+        ports:
+          - 8080:8080

historicalData/data.rtf

@@ -0,0 +1,8 @@
+{\rtf1\ansi\ansicpg1252\cocoartf2638
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+{\*\expandedcolortbl;;}
+\margl1440\margr1440\vieww11520\viewh8400\viewkind0
+\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\pardirnatural\partightenfactor0
+
+\f0\fs24 \cf0 Hello}

precipitation_function.py

@@ -0,0 +1,233 @@
+import pandas as pd
+import numpy as np
+import streamlit as st
+
+
+
+#imports for finding the nearest lat long using haversine distance
+
+#visualization libraries to visualize different plots
+import plotly.express as px
+import plotly.graph_objects as go
+import altair as alt
+import io
+
+#for Logo plotting
+from PIL import Image
+
+#disabling warnings
+import warnings
+warnings.filterwarnings("ignore")
+
+#For parallel processing
+from pandarallel import pandarallel
+pandarallel.initialize(progress_bar=True)
+
+from google.oauth2 import service_account
+from google.cloud import storage
+
+# Create API client.
+# credentials = service_account.Credentials.from_service_account_info(
+#     st.secrets["gcp_service_account"]
+# )
+# client = storage.Client(credentials=credentials)
+#
+# @st.cache(allow_output_mutation = True)
+# def read_file(bucket_name, file_path):
+#     bucket = client.bucket(bucket_name)
+#     data = bucket.blob(file_path).download_as_bytes()
+#     df = pd.read_csv(io.BytesIO(data),compression='zip')
+#     return df
+
+
+
+
+@st.cache
+def date_split(df):
+    df[['Year','Month','Day']] = df['date'].str.split('-',expand = True)
+    return df
+
+
+@st.cache(allow_output_mutation = True)
+def lat_long_process_precp(df):
+    df['lat_long'] = df['lat'].astype(str)+','+df['long'].astype(str)
+    return df
+
+
+
+@st.cache
+def drop_dup_funct(x):
+    x.drop_duplicates(inplace = True)
+    return x
+
+@st.cache(allow_output_mutation = True)
+def concat_func(x,y,a,b):
+    z = pd.concat([x,y,a,b],ignore_index = True)
+    return z
+
+@st.cache
+def lat_long_type(nn_value):
+    if isinstance(nn_value,str):
+        return nn_value
+    else:
+        return nn_value.item((0))
+
+@st.cache
+def cumulative(df,start,end):
+    df1 = df.groupby(['Year','Month'])['precip'].sum()
+    df1 = df1.reset_index()
+    df1 = df1.set_index('Year')
+    df1 = df1.loc[str(start):str(end)]
+    return df1
+
+@st.cache
+def cumulative_plot(df):
+    fig  = px.line(df, y='precip',title = 'Monthly Cumulative Precipitation')
+    fig.update_traces(line_color = 'blue')
+    fig.update_xaxes(title_text = 'Year',gridcolor = 'whitesmoke')
+    fig.update_yaxes(ticklabelposition="inside top", title= 'Monthly Cumulative Precipitation in mm',gridcolor = 'whitesmoke')
+    fig.update_layout(margin = dict(l=25,r=25,t=25,b=25))
+    fig.update_layout(plot_bgcolor = 'rgba(0,0,0,0)')
+    fig.update_layout(title = "Monthly Cumulative Precipitation")
+    return fig
+
+
+@st.cache(allow_output_mutation=True)
+def daily_precp_data(precipitation_temp,start,end,option):
+    df_daily = precipitation_temp.get_group(option)
+    df_daily.set_index('date',inplace = True)
+    # df_2 = df_daily.loc[str(start):str(end)]
+    # df_3=df_2.reset_index()
+    return df_daily
+
+@st.cache
+def daily_precp_plot(df):
+    fig  = px.line(df,y='precip',title = 'Daily Precipitation')
+    fig.update_traces(line_color = 'blue')
+    fig.update_xaxes(title_text = 'Year',gridcolor = 'whitesmoke')
+    fig.update_yaxes(ticklabelposition="inside top", title= 'Daily Precipitation in mm',gridcolor = 'whitesmoke')
+    fig.update_layout(margin = dict(l=25,r=25,t=25,b=25))
+    fig.update_layout(plot_bgcolor = 'rgba(0,0,0,0)')
+    fig.update_layout(title = "Daily Precipitation")
+    return fig
+
+
+def start_end_date_ui(start,end,key1,key2):
+    st.markdown('**Enter Start Date**')
+    start = st.date_input("",value = start,key = key1)
+    if start < pd.to_datetime('2001/01/01'):
+        st.write('Start date should not be less than 2001/01/01')
+
+    st.markdown('**Enter End Date**')
+    end = st.date_input("",value = end, key = key2)
+    if end > pd.to_datetime('2019/12/31'):
+        st.write('End date should not be greater than 2019/12/31')
+
+    return start,end
+
+
+def lat_long_ui(key1,key2):
+    st.markdown('**Enter the latitude**')
+    latitude_input = st.text_input('','12.55',key = key1)
+    st.markdown('**Enter the longitude**')
+    longitude_input = st.text_input('','42.45',key = key2)
+    return latitude_input,longitude_input
+
+
+def year_selection_ui(key1,key2):
+    st.markdown('**Select the Start Year**')
+    start_year = st.selectbox('',
+                              ('2001','2002','2003','2004','2005','2006','2007','2008','2009',
+                              '2010','2011','2012','2013','2014','2015','2016','2017','2018','2019'),key = key1)
+
+    st.markdown('**Select the End Year**')
+    end_year = st.selectbox('',
+                              ('2001','2002','2003','2004','2005','2006','2007','2008','2009',
+                              '2010','2011','2012','2013','2014','2015','2016','2017','2018','2019'),key = key2)
+
+    return start_year,end_year
+
+@st.cache(allow_output_mutation=True)
+def monthly_mean_plot(df):
+    title_text = "Monthly Mean Precipitation"
+    highlight = alt.selection(
+    type='single', on='mouseover', fields=['Year'], nearest=True)
+    base = alt.Chart(df,title = title_text).encode(
+    x = alt.X('Month:Q',scale = alt.Scale(domain=[1,12]),axis=alt.Axis(tickMinStep=1)),
+    y = alt.Y('precip:Q',scale = alt.Scale(domain=[df['precip'].min(),df['precip'].max()])),
+    color = alt.Color('Year:O',scale = alt.Scale(scheme = 'magma'))
+    )
+    points = base.mark_circle().encode(
+    opacity=alt.value(0),
+    tooltip=[
+        alt.Tooltip('Year:O', title='Year'),
+        alt.Tooltip('Month:Q', title='Month'),
+        alt.Tooltip('precip:Q', title='Monthly Mean Precipitation')
+    ]).add_selection(highlight)
+
+    lines = base.mark_line().encode(
+    size=alt.condition(~highlight, alt.value(1), alt.value(3)))
+
+    mean_chart = (points + lines).properties(width=1000, height=400).interactive()
+    return mean_chart
+
+@st.cache
+def annual_max_precip_plot(df):
+    fig_max  = px.line(df, x = 'Year',y='precip',title = 'Annual Maximum Precipitation')
+    fig_max.update_traces(line_color = 'maroon')
+    fig_max.update_xaxes(title_text = 'Year',gridcolor = 'whitesmoke')
+    fig_max.update_yaxes(ticklabelposition="inside top", title= 'Annual Maximum Precipitation in mm',gridcolor = 'whitesmoke')
+    fig_max.update_layout(margin = dict(l=25,r=25,t=25,b=25))
+    fig_max.update_layout(plot_bgcolor = 'rgba(0,0,0,0)')
+    fig_max.update_layout(title = "Annual Maximum Precipitation")
+    return fig_max
+
+
+def annual_min_precip_plot(df):
+    fig_min  = px.line(df, x = 'Year',y='precip',title = 'Annual Minimum Precipitation')
+    fig_min.update_traces(line_color = 'blue')
+    fig_min.update_xaxes(title_text = 'Year',gridcolor = 'whitesmoke')
+    fig_min.update_yaxes(ticklabelposition="inside top", title= 'Annual Minimum Precipitation in mm',gridcolor = 'whitesmoke')
+    fig_min.update_layout(margin = dict(l=25,r=25,t=25,b=25))
+    fig_min.update_layout(plot_bgcolor = 'rgba(0,0,0,0)')
+    fig_min.update_layout(title = "Annual Minimum Precipitation")
+    return fig_min
+
+def annual_avg_plot(df):
+    fig_avg  = px.line(df, x = 'Year',y='precip',title = 'Annual Average Precipitation')
+    fig_avg.update_traces(line_color = 'dimgray')
+    fig_avg.update_xaxes(title_text = 'Year',gridcolor = 'whitesmoke')
+    fig_avg.update_yaxes(ticklabelposition="inside top", title= 'Annual Average Precipitation in mm',gridcolor = 'whitesmoke')
+    fig_avg.update_layout(margin = dict(l=25,r=25,t=25,b=25))
+    fig_avg.update_layout(plot_bgcolor = 'rgba(0,0,0,0)')
+    fig_avg.update_layout(title = "Annual Average Precipitation")
+    return fig_avg
+
+
+@st.cache
+def max_precip(precipitation_temp,option,start_year,end_year):
+    maximum_precip_df = precipitation_temp.get_group(option)
+    maximum_precip_df = date_split(maximum_precip_df)
+    Annual_max_precip = maximum_precip_df.groupby('Year')['precip'].max()
+    Annual_max_precip = Annual_max_precip.loc[str(start_year):str(end_year)]
+    Annual_max_precip = Annual_max_precip.reset_index()
+    return Annual_max_precip
+
+@st.cache
+def min_precip(precipitation_temp,option,start_year,end_year):
+    minimum_precip_df = precipitation_temp.get_group(option)
+    minimum_precip_df = date_split(minimum_precip_df)
+    minimum_precip_df = minimum_precip_df.where(minimum_precip_df['precip']>0)
+    minimum_precip_df = minimum_precip_df.groupby('Year')['precip'].min()
+    minimum_precip_df = minimum_precip_df.loc[str(start_year):str(end_year)]
+    minimum_precip_df = minimum_precip_df.reset_index()
+    return minimum_precip_df
+
+@st.cache
+def avg_precip(precipitation_temp,option,start_year,end_year):
+    avg_precip_df = precipitation_temp.get_group(option)
+    avg_precip_df = date_split(avg_precip_df)
+    avg_precip_df = avg_precip_df.groupby('Year')['precip'].mean()
+    avg_precip_df_s_e = avg_precip_df.loc[str(start_year):str(end_year)]
+    avg_precip_df_s_e = avg_precip_df_s_e.reset_index()
+    return avg_precip_df_s_e

requirements.txt

@@ -0,0 +1,16 @@
+altair==4.2.0
+branca==0.5.0
+folium==0.12.1.post1
+geopy==2.2.0
+numpy==1.21.5
+pandarallel==1.6.1
+pandas==1.4.2
+Pillow==9.2.0
+plotly==5.6.0
+protobuf
+seaborn==0.11.2
+streamlit==1.11.0
+streamlit_folium==0.6.13
+google-cloud-storage==2.4.0
+swifter
+modin 

stlib/precipitation.py

@@ -0,0 +1,493 @@
+import pandas as pd
+import numpy as np
+import streamlit as st
+import folium
+import folium.plugins
+
+from streamlit_folium import st_folium
+from branca.element import Figure
+
+
+from precipitation_function import date_split,lat_long_process_precp
+from precipitation_function import concat_func, drop_dup_funct,lat_long_type
+from precipitation_function import daily_precp_plot,start_end_date_ui,lat_long_ui,year_selection_ui
+from precipitation_function import monthly_mean_plot, annual_max_precip_plot,daily_precp_data,cumulative_plot
+from precipitation_function import annual_max_precip_plot,annual_min_precip_plot,annual_avg_plot,max_precip,min_precip,avg_precip,cumulative
+
+from temperature_functions import convert_df, map_creation, search_func
+
+def run():
+    fig = Figure(width = 550,height = 350)
+
+    nearest_lat_long = 0
+    nn = 0
+    start = pd.to_datetime('2001/01/01')
+    end = pd.to_datetime('2019/12/31')
+
+    #precipitation data
+    # bucket_name = "timeseries_data_storage"
+    # file_path_1 = "precip_data/precip1.zip"
+    # file_path_2 = "precip_data/precip2.zip"
+    # file_path_3 = "precip_data/precip3.zip"
+    # file_path_4 = "precip_data/precip4.zip"
+    # file_path_5 = "precip_data/precip5.zip"
+    # file_path_6 = "precip_data/precip6.zip"
+    # file_path_7 = "precip_data/precip7.zip"
+    # file_path_8 = "precip_data/precip8.zip"
+    # file_path_9 = "precip_data/precip9.zip"
+    # file_path_10 = "precip_data/precip10.zip"
+    # file_path_11 = "precip_data/precip11.zip"
+    # file_path_12 = "precip_data/precip12.zip"
+    # file_path_13 = "precip_data/precip13.zip"
+    # file_path_14 = "precip_data/precip14.zip"
+    # file_path_15 = "precip_data/precip15.zip"
+    # file_path_16 = "precip_data/precip16.zip"
+
+
+
+    precipitation_1_og = pd.read_csv('historicalData/precip1.csv')
+    precipitation_2_og = pd.read_csv('historicalData/precip2.csv')
+    precipitation_3_og = pd.read_csv('historicalData/precip3.csv')
+    precipitation_4_og = pd.read_csv('historicalData/precip4.csv')
+    precipitation_5_og = pd.read_csv('historicalData/precip5.csv')
+    precipitation_6_og = pd.read_csv('historicalData/precip6.csv')
+    precipitation_7_og = pd.read_csv('historicalData/precip7.csv')
+    precipitation_8_og = pd.read_csv('historicalData/precip8.csv')
+    precipitation_9_og = pd.read_csv('historicalData/precip9.csv')
+    precipitation_10_og = pd.read_csv('historicalData/precip10.csv')
+    precipitation_11_og = pd.read_csv('historicalData/precip11.csv')
+    precipitation_12_og = pd.read_csv('historicalData/precip12.csv')
+    precipitation_13_og = pd.read_csv('historicalData/precip13.csv')
+    precipitation_14_og = pd.read_csv('historicalData/precip14.csv')
+    precipitation_15_og = pd.read_csv('historicalData/precip15.csv')
+    precipitation_16_og = pd.read_csv('historicalData/precip16.csv')
+
+
+    lat_long_precipitation_1 = precipitation_1_og['lat_long']
+    lat_long_precipitation_2 = precipitation_2_og['lat_long']
+    lat_long_precipitation_3 = precipitation_3_og['lat_long']
+    lat_long_precipitation_4 = precipitation_4_og['lat_long']
+    lat_long_precipitation_5 = precipitation_5_og['lat_long']
+    lat_long_precipitation_6 = precipitation_6_og['lat_long']
+    lat_long_precipitation_7 = precipitation_7_og['lat_long']
+    lat_long_precipitation_8 = precipitation_8_og['lat_long']
+    lat_long_precipitation_9 = precipitation_9_og['lat_long']
+    lat_long_precipitation_10 = precipitation_10_og['lat_long']
+    lat_long_precipitation_11 = precipitation_11_og['lat_long']
+    lat_long_precipitation_12 = precipitation_12_og['lat_long']
+    lat_long_precipitation_13 = precipitation_13_og['lat_long']
+    lat_long_precipitation_14 = precipitation_14_og['lat_long']
+    lat_long_precipitation_15 = precipitation_15_og['lat_long']
+    lat_long_precipitation_16 = precipitation_16_og['lat_long']
+
+
+
+    lat_long_precipitation_list_1 = concat_func(lat_long_precipitation_1,lat_long_precipitation_2,lat_long_precipitation_3,lat_long_precipitation_4)
+    lat_long_precipitation_list_2 = concat_func(lat_long_precipitation_5,lat_long_precipitation_6,lat_long_precipitation_7,lat_long_precipitation_8)
+    lat_long_precipitation_list_3 = concat_func(lat_long_precipitation_9,lat_long_precipitation_10,lat_long_precipitation_11,lat_long_precipitation_12)
+    lat_long_precipitation_list_4 = concat_func(lat_long_precipitation_13,lat_long_precipitation_14,lat_long_precipitation_15,lat_long_precipitation_16)
+    lat_long_precipitation_list   = concat_func(lat_long_precipitation_list_1,lat_long_precipitation_list_2,lat_long_precipitation_list_3,lat_long_precipitation_list_4)
+
+
+    precipitation_conc_1 = concat_func(precipitation_1_og,precipitation_2_og,precipitation_3_og,precipitation_4_og)
+    precipitation_conc_2 = concat_func(precipitation_5_og,precipitation_6_og,precipitation_7_og,precipitation_8_og)
+    precipitation_conc_3 = concat_func(precipitation_9_og,precipitation_10_og,precipitation_11_og,precipitation_12_og)
+    precipitation_conc_4 = concat_func(precipitation_13_og,precipitation_14_og,precipitation_15_og,precipitation_16_og)
+    precipitation = concat_func(precipitation_conc_1,precipitation_conc_2,precipitation_conc_3,precipitation_conc_4)
+
+    # precipitation = precipitation.drop([Unnamed:0.2,Unnamed:0.1,Unnamed:0],axis =1)
+    precipitation.drop(precipitation.filter(regex="Unnamed"),axis=1, inplace=True)
+    # st.write(precipitation.head())
+    precipitation_temp = precipitation.copy()
+    precipitation_temp = precipitation_temp.groupby('lat_long')
+
+    with st.sidebar:
+        data_type = st.radio("Select Data Type to View",
+                        ('Daily Precipitation','Cumulative Monthly Precipitation','Monthly Average Precipitation',
+                        'Annual Maximum Precipitation','Annual Minimum Precipitation',
+                        'Annual Average Precipitation','Annual Max, Min, & Average Precipitation'))
+
+    if data_type == "Cumulative Monthly Precipitation":
+        col1,col2 = st.columns(2)
+        with col1:
+            start_year,end_year = year_selection_ui(99,100)
+        with col2:
+            #calling the ui method to create a lat long input UI
+            latitude_input,longitude_input = lat_long_ui(300,400)
+
+
+        latitude_input,longitude_input= float(latitude_input),float(longitude_input)
+        nearest_lat_long = search_func(latitude_input,longitude_input,lat_long_precipitation_list,precipitation)
+        option = lat_long_type(nearest_lat_long)
+
+        with col1:
+            st.write("**Nearest latitude and longitude from the entered latitude longitude is :**",option)
+
+        df_cumulative = precipitation_temp.get_group(option)
+        df_cumulative = date_split(df_cumulative)
+
+        lat  = float(option.split(',')[0])
+        long = float(option.split(',')[1])
+        m = map_creation(lat,long,0,0)
+        last_click = m['last_clicked']
+
+        with col2:
+            if last_click is not None:
+                clicked_lat = last_click['lat']
+                clicked_long = last_click['lng']
+                st.markdown("**Last Clicked Latitude Longitude point is:**")
+                st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                nn = search_func(clicked_lat,clicked_long,lat_long_precipitation_list,precipitation)
+                nn = lat_long_type(nn)
+                st.write("**Nearest Latitude and Longitude is:**",nn)
+                st.markdown(" ")
+
+            else:
+                st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+
+        if last_click is not None:
+            clicked_lat = last_click['lat']
+            clicked_long = last_click['lng']
+            map_creation(lat,long,clicked_lat,clicked_long)
+
+        df_c = cumulative(df_cumulative,start_year,end_year)
+        fig_cumulative = cumulative_plot(df_c)
+        st.plotly_chart(fig_cumulative,use_container_width=True)
+        c1,c2,c3,c4,c5 = st.columns(5)
+        with c3:
+            st.download_button("Download Data",data = convert_df(df_c),
+                                file_name='cumulative_precipitation.csv',
+                                mime='text/csv',)
+
+
+    elif data_type == "Daily Precipitation":
+        col1,col2 = st.columns(2)
+        with col1:
+            #calling the ui method to create a start end date input UI
+            start,end = start_end_date_ui(start,end,11,22)
+        with col2:
+            latitude_input,longitude_input = lat_long_ui(1,2)
+
+
+        latitude_input,longitude_input= float(latitude_input),float(longitude_input)
+        nearest_lat_long = search_func(latitude_input,longitude_input,lat_long_precipitation_list,precipitation)
+        option = lat_long_type(nearest_lat_long)
+
+        with col1:
+            st.write("**Nearest latitude and longitude from the entered latitude longitude is :**",option)
+
+
+        lat  = float(option.split(',')[0])
+        long = float(option.split(',')[1])
+        m = map_creation(lat,long,0,0)
+        last_click = m['last_clicked']
+
+        with col2:
+            if last_click is not None:
+                clicked_lat = last_click['lat']
+                clicked_long = last_click['lng']
+                st.markdown("**Last Clicked Latitude Longitude point is:**")
+                st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                nn = search_func(clicked_lat,clicked_long,lat_long_precipitation_list,precipitation)
+                nn = lat_long_type(nn)
+                st.write("**Nearest Latitude and Longitude is:**",nn)
+                st.markdown(" ")
+
+            else:
+                st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+
+        if last_click is not None:
+            clicked_lat = last_click['lat']
+            clicked_long = last_click['lng']
+            map_creation(lat,long,clicked_lat,clicked_long)
+
+
+        daily_precp_df = daily_precp_data(precipitation_temp,start,end,option)
+        # st.write(daily_precp_df.head())
+        daily_precp_df.drop_duplicates(inplace = True)
+        daily_df = daily_precp_df.loc[str(start):str(end)]
+        # st.write(daily_df)
+        fig_daily_precp = daily_precp_plot(daily_df)
+        st.plotly_chart(fig_daily_precp,use_container_width = True)
+
+        c1,c2,c3,c4,c5 = st.columns(5)
+        with c3:
+            st.download_button("Download Data",data = convert_df(daily_precp_df),
+                                file_name='daily_precipitation.csv',
+                                mime='text/csv',)
+
+
+    elif data_type == 'Monthly Average Precipitation':
+        col1,col2 = st.columns(2)
+        with col1:
+            start_year,end_year = year_selection_ui(9,10)
+        with col2:
+            #calling the ui method to create a lat long input UI
+            latitude_input,longitude_input = lat_long_ui(3,4)
+
+        latitude_input,longitude_input= float(latitude_input),float(longitude_input)
+        nearest_lat_long = search_func(latitude_input,longitude_input,lat_long_precipitation_list,precipitation)
+        option = lat_long_type(nearest_lat_long)
+
+        lat  = float(option.split(',')[0])
+        long = float(option.split(',')[1])
+        m = map_creation(lat,long,0,0)
+
+        last_click = m['last_clicked']
+
+        with col1:
+            st.write("**Nearest latitude and longitude from the entered latitude longitude is :**",option)
+
+        with col2:
+            if last_click is not None:
+                clicked_lat = last_click['lat']
+                clicked_long = last_click['lng']
+                st.markdown("**Last Clicked Latitude Longitude point is:**")
+                st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                nn = search_func(clicked_lat,clicked_long,lat_long_precipitation_list,precipitation)
+                nn = lat_long_type(nn)
+                st.write("**Nearest Latitude and Longitude is:**",nn)
+                st.markdown(" ")
+
+            else:
+                st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+
+        if last_click is not None:
+            clicked_lat = last_click['lat']
+            clicked_long = last_click['lng']
+            map_creation(lat,long,clicked_lat,clicked_long)
+
+
+        precipitation_monthly_avg = precipitation_temp.get_group(option)
+        precipitation_monthly_avg = date_split(precipitation_monthly_avg)
+        precipt_monthly_avg_df = precipitation_monthly_avg.groupby(['Year','Month'],as_index=False)['precip'].mean()
+        precipt_monthly_avg_df = precipt_monthly_avg_df.set_index('Year')
+        precipitation_monthly_avg_df = precipt_monthly_avg_df.loc[str(start_year):str(end_year)]
+        precipitation_monthly_avg_df.reset_index(inplace = True)
+        mean_chart_plot = monthly_mean_plot(precipitation_monthly_avg_df)
+        st.altair_chart(mean_chart_plot)
+
+
+        c1,c2,c3,c4,c5 = st.columns(5)
+        with c3:
+            st.download_button("Download Data",data = convert_df(precipitation_monthly_avg_df),
+                                file_name='Monthly_avg_precipitation.csv',
+                                mime='text/csv',)
+
+
+    elif data_type == 'Annual Maximum Precipitation':
+        col1,col2 = st.columns(2)
+        with col1:
+            start_year,end_year = year_selection_ui(11,12)
+        with col2:
+            #calling the ui method to create a lat long input UI
+            latitude_input,longitude_input = lat_long_ui(5,6)
+
+        latitude_input,longitude_input= float(latitude_input),float(longitude_input)
+        nearest_lat_long = search_func(latitude_input,longitude_input,lat_long_precipitation_list,precipitation)
+        option = lat_long_type(nearest_lat_long)
+
+        lat  = float(option.split(',')[0])
+        long = float(option.split(',')[1])
+        m = map_creation(lat,long,0,0)
+        last_click = m['last_clicked']
+
+        with col1:
+            st.write("**Nearest latitude and longitude from the entered latitude longitude is :**",option)
+
+        with col2:
+            if last_click is not None:
+                clicked_lat = last_click['lat']
+                clicked_long = last_click['lng']
+                st.markdown("**Last Clicked Latitude Longitude point is:**")
+                st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                nn = search_func(clicked_lat,clicked_long,lat_long_precipitation_list,precipitation)
+                nn = lat_long_type(nn)
+                st.write("**Nearest Latitude and Longitude is:**",nn)
+                st.markdown(" ")
+
+            else:
+                st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+
+        if last_click is not None:
+            clicked_lat = last_click['lat']
+            clicked_long = last_click['lng']
+            map_creation(lat,long,clicked_lat,clicked_long)
+
+        Annual_max_precip = max_precip(precipitation_temp,option,start_year,end_year)
+        fig_max = annual_max_precip_plot(Annual_max_precip)
+        st.plotly_chart(fig_max,use_container_width=True)
+
+        c1,c2,c3,c4,c5 = st.columns(5)
+        with c3:
+            st.download_button("Download Data",data = convert_df(Annual_max_precip),
+                                file_name='Annual_max_precipitation.csv',
+                                mime='text/csv',)
+
+
+    elif data_type == 'Annual Minimum Precipitation':
+        col1,col2 = st.columns(2)
+        with col1:
+            start_year,end_year = year_selection_ui(13,14)
+        with col2:
+            #calling the ui method to create a lat long input UI
+            latitude_input,longitude_input = lat_long_ui(7,8)
+
+        latitude_input,longitude_input= float(latitude_input),float(longitude_input)
+        nearest_lat_long = search_func(latitude_input,longitude_input,lat_long_precipitation_list,precipitation)
+        option = lat_long_type(nearest_lat_long)
+
+        lat  = float(option.split(',')[0])
+        long = float(option.split(',')[1])
+        m = map_creation(lat,long,0,0)
+        last_click = m['last_clicked']
+
+        with col1:
+            st.write("**Nearest latitude and longitude from the entered latitude longitude is :**",option)
+
+        with col2:
+            if last_click is not None:
+                clicked_lat = last_click['lat']
+                clicked_long = last_click['lng']
+                st.markdown("**Last Clicked Latitude Longitude point is:**")
+                st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                nn = search_func(clicked_lat,clicked_long,lat_long_precipitation_list,precipitation)
+                nn = lat_long_type(nn)
+                st.write("**Nearest Latitude and Longitude is:**",nn)
+                st.markdown(" ")
+            else:
+                st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+
+        if last_click is not None:
+            clicked_lat = last_click['lat']
+            clicked_long = last_click['lng']
+            map_creation(lat,long,clicked_lat,clicked_long)
+
+
+        minimum_precip_df = min_precip(precipitation_temp,option,start_year,end_year)
+        fig_min = annual_min_precip_plot(minimum_precip_df)
+        st.plotly_chart(fig_min,use_container_width = True)
+
+
+        c1,c2,c3,c4,c5 = st.columns(5)
+        with c3:
+            st.download_button("Download Data",data = convert_df(minimum_precip_df),
+                                file_name='Annual_minimum_precipitation.csv',
+                                mime='text/csv',)
+
+
+
+    elif data_type == 'Annual Average Precipitation':
+        col1,col2 = st.columns(2)
+        with col1:
+            start_year,end_year = year_selection_ui(15,16)
+        with col2:
+            #calling the ui method to create a lat long input UI
+            latitude_input,longitude_input = lat_long_ui(9,10)
+
+        latitude_input,longitude_input= float(latitude_input),float(longitude_input)
+        nearest_lat_long = search_func(latitude_input,longitude_input,lat_long_precipitation_list,precipitation)
+        option = lat_long_type(nearest_lat_long)
+
+        lat  = float(option.split(',')[0])
+        long = float(option.split(',')[1])
+        m = map_creation(lat,long,0,0)
+        last_click = m['last_clicked']
+
+        with col1:
+            st.write("**Nearest latitude and longitude from the entered latitude longitude is :**",option)
+
+        with col2:
+            if last_click is not None:
+                clicked_lat = last_click['lat']
+                clicked_long = last_click['lng']
+                st.markdown("**Last Clicked Latitude Longitude point is:**")
+                st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                nn = search_func(clicked_lat,clicked_long,lat_long_precipitation_list,precipitation)
+                nn = lat_long_type(nn)
+                st.write("**Nearest Latitude and Longitude is:**",nn)
+                st.markdown(" ")
+            else:
+                st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+
+        if last_click is not None:
+            clicked_lat = last_click['lat']
+            clicked_long = last_click['lng']
+            map_creation(lat,long,clicked_lat,clicked_long)
+
+        avg_precip_df_se = avg_precip(precipitation_temp,option,start_year,end_year)
+        fig_avg = annual_avg_plot(avg_precip_df_se)
+        st.plotly_chart(fig_avg,use_container_width = True)
+
+        c1,c2,c3,c4,c5 = st.columns(5)
+        with c3:
+            st.download_button("Download Data",data = convert_df(avg_precip_df_se),
+                                file_name='Annual_avg_precipitation.csv',
+                                mime='text/csv',)
+
+    elif data_type == 'Annual Max, Min, & Average Precipitation':
+        col1,col2 = st.columns(2)
+        with col1:
+            start_year,end_year = year_selection_ui(17,18)
+
+        with col2:
+            latitude_input,longitude_input = lat_long_ui(11,12)
+
+        latitude_input,longitude_input= float(latitude_input),float(longitude_input)
+        nearest_lat_long = search_func(latitude_input,longitude_input,lat_long_precipitation_list,precipitation)
+        option = lat_long_type(nearest_lat_long)
+
+        lat  = float(option.split(',')[0])
+        long = float(option.split(',')[1])
+        m = map_creation(lat,long,0,0)
+
+        last_click = m['last_clicked']
+        with col1:
+            st.write("**Nearest latitude and longitude from the entered latitude longitude is :**",option)
+
+        with col2:
+            if last_click is not None:
+                clicked_lat = last_click['lat']
+                clicked_long = last_click['lng']
+                st.markdown("**Last Clicked Latitude Longitude point is:**")
+                st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                nn = search_func(clicked_lat,clicked_long,lat_long_precipitation_list,precipitation)
+                nn = lat_long_type(nn)
+                st.write("**Nearest Latitude and Longitude is:**",nn)
+                st.markdown(" ")
+            else:
+                st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+
+            if last_click is not None:
+                clicked_lat = last_click['lat']
+                clicked_long = last_click['lng']
+                map_creation(lat,long,clicked_lat,clicked_long)
+
+        col11,col22,col33 = st.columns(3)
+        with col11:
+            annual_max_data = max_precip(precipitation_temp,option,start_year,end_year)
+            fig_max_2 = annual_max_precip_plot(annual_max_data)
+            st.plotly_chart(fig_max_2,use_container_width=True)
+            st.download_button("Download Data",data = convert_df(annual_max_data),
+                                file_name='Annual_max_precipitation_data.csv',
+                                mime='text/csv',)
+
+        with col22:
+            annual_min_data = min_precip(precipitation_temp,option,start_year,end_year)
+            fig_min_2 = annual_min_precip_plot(annual_min_data)
+            st.plotly_chart(fig_min_2,use_container_width = True)
+            st.download_button("Download Data",data = convert_df(annual_min_data),
+                                file_name='Annual_min_precipitation_data.csv',
+                                mime='text/csv',)
+
+        with col33:
+            annual_avg_data = avg_precip(precipitation_temp,option,start_year,end_year)
+            fig_avg_2 = annual_avg_plot(annual_avg_data)
+            st.plotly_chart(fig_avg_2, use_container_width = True)
+            st.download_button("Download Data",data = convert_df(annual_avg_data),
+                                file_name='Annual_avg_precipitation_data.csv',
+                                mime='text/csv',)
+
+
+if __name__ == 'main':
+    run()

stlib/temperature.py

@@ -0,0 +1,484 @@
+
+
+#standard imports
+import pandas as pd
+import numpy as np
+import streamlit as st
+import swifter
+swifter.register_modin()
+from typing import Dict, List, Optional
+
+from temperature_functions import annual_avg, df_date_split, lat_long_process,lat_long_list_creation
+from temperature_functions import group_df, daily_avg, annual_avg_plot, avg_temp_plot, annual_min_plot, annual_max_plot
+from temperature_functions import daily_avg_calc, daily_avg_plot, monthly_mean_calc, selecting_mean, plot_mean_data, max_temp_plot
+from temperature_functions import min_temp_plot, convert_df, map_creation, search_func
+import folium
+from streamlit_folium import st_folium
+from branca.element import Figure
+
+
+
+import warnings
+warnings.filterwarnings("ignore")
+
+#For parallel processing
+from pandarallel import pandarallel
+pandarallel.initialize(progress_bar=True)
+
+
+
+def run():
+
+    #nearest neighbor
+    nn = 0
+    # bucket_name = 'timeseries_data_storage'
+    # file_path1 = 'temperature1.zip'
+    # file_path2 = 'temperature2.zip'
+    tempe1 = pd.read_csv('historicalData/temperature1.csv')
+    tempe2 = pd.read_csv('historicalData/temperature2.csv')
+    temperatureDF = pd.concat([tempe1,tempe2],axis =0 )
+
+    #creating copy of our dataframe
+    temperatureDataFrame = temperatureDF.copy()
+
+    #applying the function on the dataframe
+    temperatureDataFrame = lat_long_process(temperatureDataFrame)
+
+    #applying the lat long creation function on the dataframe
+    lat_long_list = lat_long_list_creation(temperatureDataFrame)
+
+    #applying the function on the dataframe
+    result = group_df(temperatureDataFrame,lat_long_list)
+
+    #Dataframe containing daily average
+    result['daily_avg'] = result.swifter.apply(lambda x: daily_avg(x.tmin,x.tmax),axis=1)
+
+
+    ### Dashboard Creation
+    #creating the Sidebar Menu
+    with st.sidebar.empty():
+        with st.container():
+            data_type = st.radio("Select Data Type to View",
+                ('Daily Average','Monthly Mean Temperature','Annual Maximum Temperature','Annual Minimum Temperature','Annual Average Temperature','Annual Max, Min, & Average Temperature'))
+
+    #dividing the screen column into 2 sections for daily_average
+    if data_type == 'Daily Average':
+        ab = st.empty()
+        a = st.empty()
+        b = st.empty()
+
+        start = pd.to_datetime('2001/01/01')
+        end = pd.to_datetime('2019/12/31')
+
+        with  ab:
+            col1,col2 = st.columns(2)
+            #creating dropdown menu for entering start and end date
+            with col1:
+                st.markdown('**Enter Start Date**')
+                start = st.date_input("",value = start,key = 1)
+                if start < pd.to_datetime('2001/01/01'):
+                    st.write('Start date should not be less than 2001/01/01')
+
+                st.markdown('**Enter End Date**')
+                end = st.date_input("",value = end, key = 2)
+                if end > pd.to_datetime('2019/12/31'):
+                    st.write('End date should not be greater than 2019/12/31')
+            #dropdown menu for selecting lat long values
+            with col2:
+                st.markdown('**Select the Latitude and Longitude**')
+                option = st.selectbox("",pd.DataFrame(lat_long_list),key = 3)
+                lat  = float(option.split(',')[0])
+                long = float(option.split(',')[1])
+                m = map_creation(lat,long,0,0)
+                last_click = m['last_clicked']
+        with a:
+            dataframe_s_e = daily_avg_calc(result,option,start,end)
+            fig = daily_avg_plot(dataframe_s_e,option)
+            st.plotly_chart(fig,use_container_width = True)
+        with b:
+            col11,col22,col33 = st.columns(3)
+            with col22:
+                st.download_button("Download Data",data = convert_df(dataframe_s_e),
+                                file_name='daily_average_temperature.csv',
+                                mime='text/csv',)
+        #finding the clicked lat long and the nearest lat long
+        with col2:
+            if last_click is not None:
+                clicked_lat = last_click['lat']
+                clicked_long = last_click['lng']
+                st.markdown("**Last Clicked Latitude Longitude point is:**")
+                st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                nn = search_func(clicked_lat,clicked_long,lat_long_list,result)
+                st.write("**Nearest Latitude and Longitude is:**",nn)
+
+            else:
+                st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+                st.markdown("   ")
+                st.markdown("   ")
+        if last_click is not None:
+            clicked_lat = last_click['lat']
+            clicked_long = last_click['lng']
+            map_creation(lat,long,clicked_lat,clicked_long)
+
+
+    #plotting the nearest neighbors graph
+        if nn != 0 :
+            df = daily_avg_calc(result,nn,start,end)
+            fig_nn = daily_avg_plot(df,nn)
+            with a:
+                st.plotly_chart(fig_nn,use_container_width = True)
+            with b:
+                col11,col22,col33 = st.columns(3)
+                with col22:
+                    st.download_button("Download Data",data = convert_df(df),
+                                        file_name='daily_average_temperature_nn.csv',
+                                        mime='text/csv',)
+
+
+    elif data_type == 'Monthly Mean Temperature':
+        #creating the UI for selecting the year,lat long
+        c = st.empty()
+        d = st.empty()
+        e = st.empty()
+        with c:
+            col1,col2 = st.columns(2)
+            with col1:
+                st.markdown('**Select the Start Year**')
+                start_year = st.selectbox('',
+                                          ('2001','2002','2003','2004','2005','2006','2007','2008','2009',
+                                          '2010','2011','2012','2013','2014','2015','2016','2017','2018','2019'),key = 4)
+
+                st.markdown('**Select the End Year**')
+                end_year = st.selectbox('',
+                                          ('2001','2002','2003','2004','2005','2006','2007','2008','2009',
+                                          '2010','2011','2012','2013','2014','2015','2016','2017','2018','2019'),key = 5)
+            with col2:
+                st.markdown('**Select the Latitude and Longitude**')
+                option_mean = st.selectbox("",pd.DataFrame(lat_long_list),key = 6)
+
+
+
+        #Finding the monthly mean/avg temperature
+        temperature_monthly_df = result.copy()
+        #function for calculating mean
+        df_mean = monthly_mean_calc(temperature_monthly_df,lat_long_list)
+        #function for selecting the specified group of lat long along with the start and end date
+        df = selecting_mean(df_mean,option_mean,start_year,end_year)
+        #function for plotting the mean data
+        mean_chart = plot_mean_data(df,option_mean)
+        with d:
+            st.altair_chart(mean_chart)
+
+        #for map
+        lat_mean  = float(option_mean.split(',')[0])
+        long_mean = float(option_mean.split(',')[1])
+
+        with col2:
+            m_mean = map_creation(lat_mean,long_mean,0,0)
+            last_click = m_mean['last_clicked']
+            if last_click is not None:
+                clicked_lat = last_click['lat']
+                clicked_long = last_click['lng']
+                st.markdown("**Last Clicked Latitude Longitude point is:**")
+                st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                nn = search_func(clicked_lat,clicked_long,lat_long_list,result)
+                st.write("**Nearest Latitude and Longitude is:**",nn)
+
+
+            else:
+                st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+                st.markdown("   ")
+                st.markdown("   ")
+
+        if last_click is not None:
+            clicked_lat = last_click['lat']
+            clicked_long = last_click['lng']
+            map_creation(lat_mean,long_mean,clicked_lat,clicked_long)
+
+        with e:
+            col11,col22,col33 = st.columns(3)
+            with col22:
+                st.download_button("Download Data",data = convert_df(df),
+                                    file_name='Monthly_mean_temperature.csv',
+                                    mime='text/csv',)
+
+                st.markdown("   ")
+
+    #code for plotting the nearest neighbors data
+
+        if nn != 0 :
+            df_nn_mean = selecting_mean(df_mean,nn,start_year,end_year)
+            fig_nn_mean = plot_mean_data(df_nn_mean,nn)
+            with d:
+                st.altair_chart(fig_nn_mean)
+            with e:
+                col11,col22,col33 = st.columns(3)
+                with col22:
+                    st.download_button("Download Data",data = convert_df(df_nn_mean),
+                                            file_name='Monthly_mean_temperature_nn.csv',
+                                            mime='text/csv',)
+
+    #code for annual maximum temperature
+    elif data_type == 'Annual Maximum Temperature':
+        g = st.empty()
+        h = st.empty()
+        i = st.empty()
+        Annual_temp = result.copy()
+        with g:
+            col1,col2 = st.columns(2)
+            with col1:
+                st.markdown('**Select the Latitude and Longitude**.')
+                option_annual_temp = st.selectbox("",pd.DataFrame(lat_long_list),key = 7)
+
+        df_max = annual_max_plot(Annual_temp,option_annual_temp,lat_long_list)
+        fig_max = max_temp_plot(df_max,option_annual_temp)
+        with h:
+            st.plotly_chart(fig_max, use_container_width=True)
+
+        #For maps
+        lat_annual_max  = float(option_annual_temp.split(',')[0])
+        long_annual_max = float(option_annual_temp.split(',')[1])
+
+        with g:
+            with col2:
+                m_max = map_creation(lat_annual_max,long_annual_max,0,0)
+                last_click = m_max['last_clicked']
+                if last_click is not None:
+                    clicked_lat = last_click['lat']
+                    clicked_long = last_click['lng']
+                    st.markdown("**Last Clicked Latitude Longitude point is:**")
+                    st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                    nn = search_func(clicked_lat,clicked_long,lat_long_list,result)
+                    st.write("**Nearest Latitude and Longitude is:**",nn)
+                else:
+                    st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+                    st.markdown("   ")
+                    st.markdown("   ")
+
+        if last_click is not None:
+            clicked_lat = last_click['lat']
+            clicked_long = last_click['lng']
+            map_creation(lat_annual_max,long_annual_max,clicked_lat,clicked_long)
+        with i:
+            col11,col22,col33 = st.columns(3)
+            with col22:
+                st.download_button("Download Data",data = convert_df(df_max),
+                                    file_name='Annual_maximum_temperature.csv',
+                                    mime='text/csv',)
+
+        with st.container():
+            if nn!=0:
+                df_max_temp_nn = annual_max_plot(Annual_temp,nn,lat_long_list)
+                fig_max_nn = max_temp_plot(df_max_temp_nn,nn)
+                with h:
+                    st.plotly_chart(fig_max_nn, use_container_width = True)
+                with i:
+                    col11,col22,col33 = st.columns(3)
+                    with col22:
+                        st.download_button("Download Data",data = convert_df(df_max_temp_nn),
+                                            file_name='Annual_maximum_temperature_nn.csv',
+                                            mime='text/csv',)
+
+
+    elif data_type == 'Annual Minimum Temperature':
+        j = st.empty()
+        k = st.empty()
+        l = st.empty()
+
+        with j:
+            col1,col2 = st.columns(2)
+            with col1:
+                st.markdown('**Select the Latitude and Longitude**.')
+                option_annual_min_temp = st.selectbox("", pd.DataFrame(lat_long_list),key = 8)
+
+        Annual_temp_min = result.copy()
+        df_min = annual_min_plot(Annual_temp_min,option_annual_min_temp,lat_long_list)
+        fig_min = min_temp_plot(df_min,option_annual_min_temp)
+
+        with k:
+            st.plotly_chart(fig_min,use_container_width = True)
+
+        #For maps
+        lat_min  = float(option_annual_min_temp.split(',')[0])
+        long_min = float(option_annual_min_temp.split(',')[1])
+
+        with j:
+            with col2:
+                m_min = map_creation(lat_min,long_min,0,0)
+                last_click = m_min['last_clicked']
+                if last_click is not None:
+                    clicked_lat = last_click['lat']
+                    clicked_long = last_click['lng']
+                    st.markdown("**Last Clicked Latitude Longitude point is:**")
+                    st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                    nn = search_func(clicked_lat,clicked_long,lat_long_list,result)
+                    st.write("**Nearest Latitude and Longitude is:**",nn)
+
+                else:
+                    st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+                    st.markdown("   ")
+                    st.markdown("   ")
+        with l:
+            col100,col200,col300 = st.columns(3)
+            with col200:
+                st.download_button("Download Data",data = convert_df(df_min),
+                                    file_name='Annual_minimum_temperature.csv',
+                                    mime='text/csv',)
+
+        with st.container():
+            if nn!=0:
+                nn_min_temp_df = annual_min_plot(Annual_temp_min,nn,lat_long_list)
+                fig_min_nn = min_temp_plot(nn_min_temp_df,nn)
+                with k:
+                    st.plotly_chart(fig_min_nn, use_container_width = True)
+                with l:
+                    col11,col22,col33 = st.columns(3)
+                    with col22:
+                        st.download_button("Download Data",data = convert_df(nn_min_temp_df),
+                                        file_name='Annual_minimum_temperature_nn.csv',
+                                        mime='text/csv',)
+
+
+    elif data_type == 'Annual Average Temperature':
+        m = st.empty()
+        n = st.empty()
+        o = st.empty()
+        annual_avg_df = result.copy()
+        with m:
+            col1,col2 = st.columns(2)
+            with col1:
+                st.markdown('**Select the Latitude and Longitude**')
+                annual_avg_option = st.selectbox("",pd.DataFrame(lat_long_list),key = 9)
+                annual_temp = annual_avg_plot(annual_avg_df,annual_avg_option,lat_long_list)
+        with n:
+            fig_avg = avg_temp_plot(annual_temp,annual_avg_option)
+            st.plotly_chart(fig_avg,use_container_width = True)
+        with o:
+            col11,col22,col33 = st.columns(3)
+            with col22:
+                st.download_button("Download Data",
+                               data = convert_df(annual_temp),
+                               file_name='Annual_average_temperature.csv',
+                               mime='text/csv',)
+    #For maps
+        lat_avg  = float(annual_avg_option.split(',')[0])
+        long_avg = float(annual_avg_option.split(',')[1])
+        with m:
+            with col2:
+                m_avg = map_creation(lat_avg,long_avg,0,0)
+                last_click = m_avg['last_clicked']
+                if last_click is not None:
+                    clicked_lat = last_click['lat']
+                    clicked_long = last_click['lng']
+                    st.markdown("**Last Clicked Latitude Longitude point is:**")
+                    st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+                    nn = search_func(clicked_lat,clicked_long,lat_long_list,result)
+                    st.write("**Nearest Latitude and Longitude is:**",nn)
+
+                else:
+                    st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+
+        with st.container():
+            if nn!=0:
+                nn_avg_temp_df = annual_avg_plot(annual_avg_df,nn,lat_long_list)
+                fig_avg_nn = avg_temp_plot(nn_avg_temp_df,nn)
+                with n:
+                    st.plotly_chart(fig_avg_nn, use_container_width = True)
+                with o:
+                    col11,col22,col33 = st.columns(3)
+                    with col22:
+                        st.download_button("Download Data",
+                                        data = convert_df(nn_avg_temp_df),
+                                        file_name='Annual_average_temperature_nn.csv',
+                                        mime='text/csv',)
+
+
+    elif data_type == 'Annual Max, Min, & Average Temperature':
+            df = result.copy()
+            col1,col2 = st.columns(2)
+            with col1:
+                st.markdown('**Select the Latitude and Longitude**.')
+                option_lat_long = st.selectbox("",pd.DataFrame(lat_long_list),key = 10)
+
+            with col2:
+                #For maps
+                lat_avg_3  = float(option_lat_long.split(',')[0])
+                long_avg_3 = float(option_lat_long.split(',')[1])
+                m_max_min_avg = map_creation(lat_avg_3,long_avg_3,0,0)
+
+                last_click = m_max_min_avg['last_clicked']
+                if last_click is not None:
+                    clicked_lat = last_click['lat']
+                    clicked_long = last_click['lng']
+                    st.markdown("**Last Clicked Latitude Longitude point is:**")
+                    st.markdown(" ")
+                    st.markdown(" ")
+                    st.write("{:0.2f},{:0.2f}".format(clicked_lat,clicked_long))
+
+                    nn = search_func(clicked_lat,clicked_long,lat_long_list,result)
+                    st.write("**Nearest Latitude and Longitude is:**",nn)
+
+                else:
+                    st.markdown("**Click on the map to fetch the Latitude and Longitude**")
+
+            col1,col2,col3 = st.columns(3)
+            with col1:
+                df1 = annual_max_plot(df,option_lat_long,lat_long_list)
+                fig_2 = max_temp_plot(df1,option_lat_long)
+                st.plotly_chart(fig_2, use_container_width=True)
+                st.download_button("Download Data",
+                                data = convert_df(df1),
+                                file_name='Annual_maximum_temperature.csv',
+                                mime='text/csv',)
+
+                with st.container():
+                    if nn!=0:
+                        df_annual_max_2 = annual_max_plot(df,nn,lat_long_list)
+                        fig_annual_max_nn_2 = max_temp_plot(df_annual_max_2,nn)
+                        st.plotly_chart(fig_annual_max_nn_2, use_container_width=True)
+                        st.download_button("Download Data",
+                                        data = convert_df(df_annual_max_2),
+                                        file_name='Annual_maximum_temperature_nn.csv',
+                                        mime='text/csv',)
+
+            with col2:
+                with st.container():
+                    df2 = annual_min_plot(df,option_lat_long,lat_long_list)
+                    fig_3 = min_temp_plot(df2,option_lat_long)
+                    st.plotly_chart(fig_3,use_container_width = True)
+                    st.download_button("Download Data",
+                                    data = convert_df(df2),
+                                    file_name='Annual_minimum_temperature.csv',
+                                    mime='text/csv',)
+                with st.container():
+                    if nn!=0:
+                        df_annual_min_2 = annual_min_plot(df,nn,lat_long_list)
+                        fig_annual_min_nn_2 = min_temp_plot(df_annual_min_2,nn)
+                        st.plotly_chart(fig_annual_min_nn_2, use_container_width=True)
+                        st.download_button("Download Data",
+                                        data = convert_df(df_annual_min_2),
+                                        file_name='Annual_minimum_temperature_nn.csv',
+                                        mime='text/csv',)
+            with col3:
+                with st.container():
+                    annual_average = annual_avg_plot(df,option_lat_long,lat_long_list)
+                    fig_4 = avg_temp_plot(annual_average,option_lat_long)
+                    st.plotly_chart(fig_4,use_container_width = True)
+
+                    st.download_button("Download Data",
+                                    data = convert_df(annual_average),
+                                    file_name='Annual_average_temperature.csv',
+                                    mime='text/csv',)
+
+                with st.container():
+                    if nn!=0:
+                        df_annual_avg_nn_2 = annual_avg_plot(df,nn,lat_long_list)
+                        fig_nn_4 = avg_temp_plot(df_annual_avg_nn_2,nn)
+                        st.plotly_chart(fig_nn_4,use_container_width=True)
+                        st.download_button("Download Data",
+                                        data = convert_df(df_annual_avg_nn_2),
+                                        file_name='Annual_average_temperature_nn.csv',
+                                        mime='text/csv',)
+
+if __name__ == 'main':
+    run()

temperature_functions.py

@@ -0,0 +1,284 @@
+#standard imports
+import pandas as pd
+import numpy as np
+import streamlit as st
+import os
+import glob
+
+
+#imports for finding the nearest lat long using haversine distance
+from math import radians, cos, sin, asin, sqrt
+import math
+
+#visualization libraries to visualize different plots
+import plotly.express as px
+import plotly.graph_objects as go
+import altair as alt
+
+
+#for Logo plotting
+from PIL import Image
+
+#for Folium Map Creation
+from typing import Dict, List, Optional
+import folium
+from streamlit_folium import st_folium
+from branca.element import Figure
+from precipitation_function import lat_long_type
+
+#disabling warnings
+import warnings
+warnings.filterwarnings("ignore")
+
+#For parallel processing
+from pandarallel import pandarallel
+pandarallel.initialize(progress_bar=True)
+
+
+
+fig = Figure(width = 550,height = 350)
+
+#function for calculating annual average
+@st.cache
+def annual_avg(df,year_lst):
+    annual_avg_df_lst = list()
+    for i in year_lst:
+        d = df.get_group((i))
+        d['Annual avg'] = (d['daily_avg'].sum())/len(d)
+        annual_avg_df_lst.append(d)
+    return annual_avg_df_lst
+
+
+#function for splitting the date column values into year, month and day
+def df_date_split(df,lat_long_list):
+    df_date_list = list()
+    for i in lat_long_list:
+        grouped_df = df.get_group(i)
+        grouped_df[['Year','Month','Day']] = grouped_df['date'].str.split('-',expand = True)
+        df_date_list.append(grouped_df)
+    date_split_df = pd.concat(df_date_list)
+    return date_split_df
+
+
+@st.cache
+#function for creating 2 separate columns one for country code with 'et' values and 2nd with lat long concated values
+def lat_long_process(df):
+    df['lat_long'] = df.loc[:,'lat'].astype(str)+','+df.loc[:,'long'].astype(str)
+    df.drop_duplicates(inplace = True)
+    return df
+
+@st.cache
+#Creating a separate dataframe for lat long values and returning a list of lat_long values
+def lat_long_list_creation(df):
+    lat_long_df = df[['lat','long']]
+    lat_long_df['lat_long'] = lat_long_df.loc[:,'lat'].astype(str)+','+lat_long_df.loc[:,'long'].astype(str)
+    lat_long_df.drop_duplicates(inplace=True)
+    lat_long_list = lat_long_df['lat_long']
+    return lat_long_list
+
+
+#function for grouping the data on lat long and returning only the et lat long
+def group_df(df,lat_long_lst):
+    in_names = df.groupby(df['lat_long'])
+    temperaturedf_new = list()
+    for i in lat_long_lst:
+        df1 = in_names.get_group(i)
+        temperaturedf_new.append(df1)
+    result = pd.concat(temperaturedf_new)
+    return result
+
+
+#function for calculating daily average
+def daily_avg(x,y):
+    return (x+y)/2
+
+
+
+@st.cache
+#creating avg dataframe
+def annual_avg_plot(annual_avg_df,lat_long_option,lat_long_list):
+    annual_avg_df = annual_avg_df.groupby('lat_long')
+    annual_avg_df = df_date_split(annual_avg_df,lat_long_list)
+    annual_avg_df = annual_avg_df.groupby('lat_long')
+    annual_avg_df = annual_avg_df.get_group(lat_long_option)
+    #returns the list of unique year values
+    year_lst = annual_avg_df['Year'].unique()
+    annual_avg_dataframe = annual_avg_df.groupby('Year')
+    annual_avg_result = annual_avg(annual_avg_dataframe,year_lst)
+    annual_average = pd.concat(annual_avg_result,axis = 0)
+    return annual_average
+
+
+#creating average temp plotly chart
+def avg_temp_plot(annual_temp,lat_long_val):
+    #CODE FOR PLOTTING ANNUAL AVERAGE TEMPERATURE
+    fig_avg = px.line(annual_temp, x= 'Year',y='Annual avg')
+    fig_avg.update_layout(
+    yaxis = dict(tickfont = dict(size=15)),
+    xaxis = dict(tickfont = dict(size=15)),
+    plot_bgcolor = 'rgba(0,0,0,0)')
+    fig_avg.update_traces(line_color ='dimgray')
+    fig_avg.update_xaxes(gridcolor='whitesmoke')
+    fig_avg.update_yaxes(gridcolor = 'whitesmoke')
+    fig_avg.update_yaxes(title = 'Annual Average Temperature (C)')
+    # fig_avg.update_layout(title = "Annual Average Temperature: "+str(lat_long_val))
+
+    return fig_avg
+
+
+@st.cache
+def annual_min_plot(Annual_temp_min,option_annual_min_temp,lat_long_list):
+    Annual_temp_min = Annual_temp_min.groupby('lat_long')
+    Annual_temp_min = df_date_split(Annual_temp_min,lat_long_list)
+    Annual_temp_min = Annual_temp_min.groupby(['lat_long','Year'])[['tmin']].min()
+    Annual_temp_min.rename(columns = {'tmin':'Yearly_minimum_temp'},inplace = True)
+    Annual_temp_min.reset_index(inplace = True)
+    Annual_temp_min = Annual_temp_min.groupby('lat_long')
+    df2 = Annual_temp_min.get_group(option_annual_min_temp)
+    return df2
+
+@st.cache
+def annual_max_plot(Annual_temp,option_annual_temp,lat_long_list):
+    Annual_temp = Annual_temp.groupby('lat_long')
+    Annual_temp = df_date_split(Annual_temp,lat_long_list)
+    Annual_temp = Annual_temp.groupby(['lat_long','Year'])[['tmax']].max()
+    Annual_temp.rename(columns = {'tmax':'Yearly_maximum_temp'},inplace = True)
+    Annual_temp.reset_index(inplace = True)
+    Annual_temp = Annual_temp.groupby('lat_long')
+    df1 = Annual_temp.get_group(option_annual_temp)
+    return df1
+
+
+@st.cache
+def daily_avg_calc(result,option,start,end):
+    grouped_temperature_df = result.groupby('lat_long')
+    data_frame = grouped_temperature_df.get_group(option)
+    data_frame.set_index('date',inplace = True)
+    data_frame_start_end = data_frame.loc[str(start):str(end)]
+    data_frame_start_end = data_frame_start_end.reset_index()
+    return data_frame_start_end
+
+def daily_avg_plot(data_frame_start_end,lat_long_val):
+    #Plotting the line chart of the daily average
+    fig  = px.line(data_frame_start_end, x = 'date',y='daily_avg',title = 'Daily Average Temperature')
+    fig.update_traces(line_color = 'blue')
+    fig.update_xaxes(title_text = 'Year',gridcolor = 'whitesmoke')
+    fig.update_yaxes(ticklabelposition="inside top", title= 'Daily Average Temperature (C)',gridcolor = 'whitesmoke')
+    fig.update_layout(margin = dict(l=25,r=25,t=25,b=25))
+    fig.update_layout(plot_bgcolor = 'rgba(0,0,0,0)')
+    # fig.update_layout(title = "Daily Average Temperature: "+str(lat_long_val))
+    return fig
+
+@st.cache
+def monthly_mean_calc(temperature_monthly_df,lat_long_list):
+    #monthly mean calculation
+    temperature_monthly_df = temperature_monthly_df.groupby('lat_long')
+    date_split_df = df_date_split(temperature_monthly_df,lat_long_list)
+    monthly_avg_temp = date_split_df.groupby(['lat_long','Year','Month'])[['daily_avg']].mean()
+    monthly_avg_temp.rename(columns = {'daily_avg':'Monthly mean temperature'},inplace = True)
+    return monthly_avg_temp
+
+
+@st.cache(ttl=24*60*60)
+def selecting_mean(monthly_avg_temp,option_mean,start_year,end_year):
+    monthly_avg_temp = monthly_avg_temp.reset_index().set_index('Year').groupby('lat_long')
+    grouped_monthly_mean = monthly_avg_temp.get_group(option_mean)
+    df = grouped_monthly_mean.loc[start_year:end_year]
+    df = df.reset_index()
+    return df
+
+
+def plot_mean_data(df,lat_long_val):
+    title_text = "Monthly Mean Temperature: "+str(lat_long_val)
+    highlight = alt.selection(
+    type='single', on='mouseover', fields=['Year'], nearest=True)
+    base = alt.Chart(df,title = title_text).encode(
+    x = alt.X('Month:Q',scale = alt.Scale(domain=[1,12]),axis=alt.Axis(tickMinStep=1)),
+    y = alt.Y('Monthly mean temperature:Q',scale = alt.Scale(domain =[int(df['Monthly mean temperature'].min()),int(df['Monthly mean temperature'].max())])),
+    color = alt.Color('Year:O',scale = alt.Scale(scheme = 'magma'))
+    )
+    points = base.mark_circle().encode(
+    opacity=alt.value(0),
+    tooltip=[
+        alt.Tooltip('Year:O', title='Year'),
+        alt.Tooltip('Month:Q', title='Month'),
+        alt.Tooltip('Monthly mean temperature:Q', title='Mean temp')
+    ]).add_selection(highlight)
+
+    lines = base.mark_line().encode(
+    size=alt.condition(~highlight, alt.value(1), alt.value(3)))
+
+    mean_chart = (points + lines).properties(width=1000, height=450).interactive()
+    return mean_chart
+
+def max_temp_plot(df_max,lat_long_val):
+    fig_max = px.line(df_max,x = 'Year',y='Yearly_maximum_temp')
+    fig_max.update_traces(line_color = 'maroon')
+    fig_max.update_layout(
+    yaxis = dict(tickfont = dict(size=15)),
+    xaxis = dict(tickfont = dict(size=15)),
+    plot_bgcolor = 'rgba(0,0,0,0)')
+    fig_max.update_xaxes(gridcolor='whitesmoke')
+    fig_max.update_yaxes(gridcolor = 'whitesmoke')
+    fig_max.update_yaxes(title = "Annual Maximum Temperature (C)")
+    # fig_max.update_layout(title = "Yearly Maximum Temperature: "+str(lat_long_val))
+
+    return fig_max
+
+
+def min_temp_plot(df_min,lat_long_val):
+    fig_min = px.line(df_min, x= 'Year',y = 'Yearly_minimum_temp')
+    fig_min.update_traces(line_color ='blue')
+    fig_min.update_layout(
+    yaxis = dict(tickfont = dict(size=15)),
+    xaxis = dict(tickfont = dict(size=15)),
+    plot_bgcolor = 'rgba(0,0,0,0)')
+    fig_min.update_xaxes(gridcolor='whitesmoke')
+    fig_min.update_yaxes(gridcolor = 'whitesmoke')
+    fig_min.update_yaxes(title = "Annual Minimum Temperature (C)")
+    # fig_min.update_layout(title = "Yearly Minimum Temperature: "+str(lat_long_val))
+
+    return fig_min
+
+
+#code for downloading Data as a CSV File
+@st.cache
+def convert_df(df):
+     return df.to_csv().encode('utf-8')
+
+# a = st.sidebar.empty()
+
+#result dataframe contains the daily average value as well.
+#Function for creating folium map and returning the latitude and Longitude of the clicked location
+def map_creation(lat,long,clicked_lat,clicked_long):
+    with st.sidebar:
+        m = folium.Map(location = [9.14,40],zoom_start =7)
+        fig.add_child(m)
+        tile = folium.TileLayer(
+        tiles = 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+        attr = 'Esri',
+        name = 'Esri Satellite',
+        overlay = False,
+        control = True).add_to(m)
+        folium.TileLayer('Stamen Terrain').add_to(m)
+        folium.TileLayer('Stamen Water Color').add_to(m)
+        folium.LayerControl().add_to(m)
+        if (clicked_lat == 0) and (clicked_long == 0):
+            folium.Marker([lat,long]).add_to(m)
+        else:
+            folium.Marker([lat,long]).add_to(m)
+            folium.Marker([clicked_lat,clicked_long]).add_to(m)
+        st_data = st_folium(m,key = 'map_fig_1')
+        return st_data
+
+#df is the initial df that contains only et data
+def search_func(latitude,longitude,lt_lng_lst,df):
+    df['lat_radian'],df['long_radian'] = np.radians(df['lat']),np.radians(df['long'])
+    df['dLON'] = df['long_radian'] - math.radians(longitude)
+    df['dLAT'] = df['lat_radian'] - math.radians(latitude)
+    df['distance'] = 6371 * 2 * np.arcsin(np.sqrt(np.sin(df['dLAT']/2)**2 + math.cos(math.radians(longitude)) * np.cos(df['lat_radian']) * np.sin(df['dLON']/2)**2))
+    a = df['distance'].idxmin()
+    nearest_neighbor = df._get_value(a,'lat_long')
+    nearest_neighbor = lat_long_type(nearest_neighbor)
+        # st.write("**Nearest Latitude and Longitude is :**",nearest_neighbor)
+    return nearest_neighbor