filter modification

ErrorHandler.py

@@ -0,0 +1,23 @@
+import streamlit as st
+import pandas as pd
+import datetime
+
+class ErrorHandler:
+    def __init__(self,):
+        pass
+
+    def time_input_validation(self, from_date:datetime, to_date:datetime, agg_level):
+        """
+        Method for validation of user input for filtering the time data of the dashboard
+        :param from_date: date of starting the time range aggregation
+        :param to_date: last date of selected time range
+        :param agg_level: time aggregation level
+        """
+        # check date logic
+        if to_date < from_date:
+            st.error("Start-Datum muss vor dem End-datum sein.")
+            st.stop()
+        # check size of time range
+        if (to_date-from_date).days < agg_level:
+            st.error("Zwischen dem Start- und End-Datum sollte mindestens ein Zeitinterval liegen.")
+            st.stop()

Visualization.py

@@ -1,23 +1,48 @@
 import streamlit as st
 import pandas as pd
+from shapely.geometry import Point
 import folium
 import plotly.graph_objects as go
+from ErrorHandler import ErrorHandler
 
 class Visualization:
     def __init__(self, df):
         self.weekdays = ['Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag', 'Samstag', 'Sonntag']
         # time series metrics
-        self.ts_metrics = {'Erschütterungsgrad':'logVScore', 'Anzahl Fahrten':'ride_id', 'kumulierte Fahrten':'n_rides', 
-                         'Geschwindigkeit':'speed', 'Normalisierte Geschwindigkeit':'norm_speed', 'Bremsungen':'breaks', 
-                         'Anomalien':'anomaly', 'Zeitverlust':'time_loss', 'Wartezeit':'waiting', }
+        self.ts_metrics = {'Anomaliegrad':'anomaly', 'Anzahl Durchfahrten':'ride_id', 'Bremsungen':'breaks', 
+                           'Erschütterungsgrad':'logVScore', 'Geschwindigkeit':'speed', 'Normalisierte Geschwindigkeit':'norm_speed',  
+                           'Wartezeit':'waiting', 'Zeitverlust':'time_loss', 'kumulierte Durchfahrten':'n_rides'}
         # metrics for hour and weekday plot
-        self.hw_metrics = {'Anzahl Fahrten':'ride_id', 'Geschwindigkeit':'speed', 'Normalisierte Geschwindigkeit':'norm_speed', 
-                           'Bremsungen':'breaks', 'Zeitverlust':'time_loss', 'Wartezeit':'waiting', }
+        self.hw_metrics = {'Anzahl Durchfahrten':'ride_id', 'Bremsungen':'breaks', 'Geschwindigkeit':'speed', 
+                           'Normalisierte Geschwindigkeit':'norm_speed', 'Wartezeit':'waiting', 'Zeitverlust':'time_loss'}
         #
         self.df:pd.DataFrame = df
-        self.min_date = df['date'].min()
-        self.max_date = df['date'].max()
         self.min_rides = 10
+        if 'from_date' not in st.session_state:
+            self.init_session_state(df)
+        
+        self.errorhandler = ErrorHandler()
+
+    def init_session_state(self, df):
+        """
+        Method for initialisation of the session state for the dashboard
+        """
+        st.session_state['min_date'] = pd.to_datetime(df['date'].min())
+        st.session_state['from_date'] = pd.to_datetime(df['date'].min())
+        st.session_state['max_date'] = pd.to_datetime(df['date'].max())
+        st.session_state['to_date'] = pd.to_datetime(df['date'].max())
+        st.session_state['agg_level'] = 7 #days
+        st.session_state['max_level'] = (st.session_state['to_date']-st.session_state['from_date']).days
+
+    def set_date_input_clb(self,):
+        st.session_state['from_date'] = max(st.session_state['min_date'], pd.to_datetime(st.session_state['from_date_input']))
+        st.session_state['to_date'] =  min(st.session_state['max_date'], pd.to_datetime(st.session_state['to_date_input']))
+        
+        st.session_state['max_level'] = (st.session_state['to_date']-st.session_state['from_date']).days
+        if st.session_state['max_level'] > st.session_state['input_agg_level']:
+            st.session_state['agg_level'] = st.session_state['input_agg_level']
+        else: 
+            st.session_state['agg_level'] = st.session_state['max_level']
 
     def filter_component(self, st_obj=st):
         """
@@ -26,21 +51,37 @@ class Visualization:
         """
         # buold filter container
         container = st_obj.container(border=True)
-        cols = container.columns([5,1,1,1])
+        cols = container.columns([5,2,1,1])
         # interval filter
-        self.selected_time = cols[0].radio('Zeitinterval:', ['Zeitinterval', 'Tageszeit', 'Wochentage'], horizontal=True)
+        self.selected_time = cols[0].radio('Zeitbereich:', ['Zeitinterval', 'Tageszeit', 'Wochentage'], horizontal=True)
+        self.agg_level = 0 
+        if self.selected_time == 'Zeitinterval':
+            # date aggrgation level
+            cols[1].number_input('Zeitinterval in Tagen', 
+                                value=st.session_state['agg_level'], step=1, 
+                                min_value=1, max_value=st.session_state['max_level'], 
+                                key='input_agg_level', on_change=self.set_date_input_clb, 
+                                help=self.helper_aggregation_level())
+            self.agg_level = st.session_state['agg_level']
         # time range filter
-        self.from_date = pd.to_datetime(cols[1].date_input('Von', value=self.min_date,
-                                        help=self.helper_date_selection('Start')))
-        self.to_date = pd.to_datetime(cols[2].date_input('Bis', value=self.max_date,
-                                      help=self.helper_date_selection('End')))
-        # date aggrgation level
-        self.agg_level = cols[3].number_input('Zeitinterval in Tagen', value=7, step=1, min_value=1, 
-                                              help=self.helper_aggregation_level())
+        cols[2].date_input('Von', value = st.session_state['from_date'], 
+                            min_value=st.session_state['min_date'], 
+                            max_value=st.session_state['to_date']-pd.Timedelta(f"{self.agg_level}d"),
+                            format="DD.MM.YYYY", key='from_date_input', on_change=self.set_date_input_clb, 
+                            help=self.helper_date_selection('Start'))
+        
+        cols[3].date_input('Bis', value = st.session_state['to_date'],
+                            min_value=st.session_state['from_date']+pd.Timedelta(f"{self.agg_level}d") , 
+                            max_value=st.session_state['max_date'],
+                            format="DD.MM.YYYY", key='to_date_input', on_change=self.set_date_input_clb, 
+                            help=self.helper_date_selection('End'))
+        
         # metric filter
+        metric_index = 0
         if self.selected_time == 'Zeitinterval':
             metrics = self.ts_metrics
             self.time_column = 'date'
+            metric_index = 3
         elif self.selected_time == 'Wochentage':
             metrics = self.hw_metrics
             self.time_column = 'weekday'
@@ -48,19 +89,21 @@ class Visualization:
             metrics = self.hw_metrics
             self.time_column = 'hour'
         # metric filter
-        self.selected_metric = container.radio('Metriken:', metrics, horizontal=True)
+        self.selected_metric = container.radio('Metriken:', metrics, horizontal=True, index=metric_index)
         self.selected_key = metrics[self.selected_metric]
+        # controll user input
+        self.errorhandler.time_input_validation(st.session_state['from_date'] , st.session_state['to_date'], self.agg_level)
 
     def aggregate_data(self):
         """
         Method for filtering the data for visualization
         """
         # select data in seleced time range
-        data = self.df[self.df['date'].between(self.from_date, self.to_date)].reset_index(drop=True)
+        data = self.df[self.df['date'].between(st.session_state['from_date'] , st.session_state['to_date'])].reset_index(drop=True)
         # aggregate data on time level
         if self.selected_time == 'Zeitinterval':
             data = data.groupby(['direction'])
-            data = data.resample(f'{self.agg_level}d', on='date', origin=self.min_date)
+            data = data.resample(f'{self.agg_level}d', on='date', origin=st.session_state['min_date'])
         elif self.selected_time == 'Tageszeit':
             data = data.groupby(['direction', 'hour'])
         else:
@@ -83,7 +126,7 @@ class Visualization:
             plot = pd.DataFrame(range(24), columns=['number'], index=range(24))
             df = df.merge(plot, left_on='hour', right_on='number', how='outer')
         else:
-            date_series =  pd.date_range(self.min_date, self.max_date, freq=f'{self.agg_level}d')
+            date_series =  pd.date_range(st.session_state['min_date'], st.session_state['max_date'], freq=f'{self.agg_level}d')
             plot = pd.DataFrame(date_series, columns=['number'])
             df = df.merge(plot, left_on='date', right_on='number', how='outer')
         # fill misssing data and sort values for right visualization
@@ -132,8 +175,9 @@ class Visualization:
         :return m: folium map object
         """
         point = gdf.at[0,'geometry'].centroid
-        m = folium.Map(location=[point.y, point.x], zoom_start=16)
+        m = folium.Map(location=[point.y, point.x], zoom_start=16, tiles='CartoDB Positron')
         folium.Choropleth(gdf.at[0,'geometry'], fill_color='blue', line_color='blue').add_to(m)
+        folium.FitOverlays().add_to(m)
         return m
     
     def timeline_plot_plotly(self):
@@ -172,7 +216,6 @@ class Visualization:
             min_value = min(value_bounds[0])
             max_value = max(value_bounds[1])
             for date in set(low_rides_dates):
-                
                 fig.add_shape(dict(type="rect", 
                                    x0=date-width, y0=min_value-abs(.25*min_value), 
                                    x1=date+width, y1=max_value+abs(.25*max_value),
@@ -184,7 +227,8 @@ class Visualization:
             xaxis_title=self.selected_time,
             yaxis_title=self.selected_metric,
             legend=dict( y=1.02, xanchor="right", x=1, traceorder="normal", orientation="h"),
-            showlegend=True
+            showlegend=True,
+            xaxis_range=[st.session_state['from_date'], st.session_state['to_date']]
         )
 
         return fig

app.py

@@ -16,23 +16,22 @@ def main(edge_id):
     # head metrics of the shapes
     cols = st.columns([4,1])
     metric_cols = cols[0].columns(5)
-    metric_cols[0].container(border=True).metric('Gesamtzahl Fahrten:', visu.int2str(data['ride_id'].sum()))
+    metric_cols[0].container(border=True).metric('Durchfahrten:', visu.int2str(data['ride_id'].sum()))
     metric_cols[0].markdown(' ')
-    metric_cols[1].container(border=True).metric('Geschwindigkeit:', f"{visu.float2str(data['speed'].mean())}km/h")
-    metric_cols[2].container(border=True).metric('Erreichte Wunshgeschwindigkeit:', f"{visu.float2str(100*data['norm_speed'].mean())}%")
-    metric_cols[3].container(border=True).metric('Zeitverlust:', f"{visu.float2str(data['time_loss'].mean())}s")
-    metric_cols[4].container(border=True).metric('Wartezeit:', f"{visu.float2str(100*data['waiting'].mean())}s")
+    metric_cols[1].container(border=True).metric('Geschwindigkeit [km/h]', f"{visu.float2str(data['speed'].mean())}")
+    metric_cols[2].container(border=True).metric('Wunschgeschwindigkeit [%]', f"{visu.float2str(100*data['norm_speed'].mean())}")
+    metric_cols[3].container(border=True).metric('Zeitverlust [Sekunden]', f"{visu.float2str(data['time_loss'].mean())}")
+    metric_cols[4].container(border=True).metric('Wartezeit [Sekunden]', f"{visu.float2str(100*data['waiting'].mean())}")
     # show shape on map
     with cols[1]:
-        st_folium(visu.create_map(geom), returned_objects=[],  key=f'Map',  width=500, height=300,)
+        st_folium(visu.create_map(geom), returned_objects=[], 
+                  key=f'Map', use_container_width=True)
     # create user filter and aggregate data based on the filter parameter
     visu.filter_component(cols[0])
     visu.aggregate_data()
     # timeline plot
-    st.markdown(f"{visu.selected_metric} pro {visu.selected_time}", help=visu.helper_plot_regions())
-    st.plotly_chart(visu.timeline_plot_plotly(), use_container_width=True)
-
-
+    cols[0].markdown(f"{visu.selected_metric} pro {visu.selected_time}", help=visu.helper_plot_regions())
+    cols[0].plotly_chart(visu.timeline_plot_plotly(), use_container_width=True)
 
 if __name__ == '__main__':
     # handle empty query parameter or processing edge/osm id

requirements.txt

@@ -14,7 +14,7 @@ colorlog==6.7.0
 contourpy==1.1.1
 cycler==0.12.1
 fiona==1.9.5
-folium==0.14.0
+folium==0.16.0
 fonttools==4.43.1
 geopandas==0.14.0
 gitdb==4.0.11