Change display order (#252)

* add detection selection

* add style

* drop debug print

* fix update

* fix input

* fix marsk

Author: MateoLostanlen

app/callbacks/data_callbacks.py

@@ -134,6 +134,20 @@ def login_callback(n_clicks, username, password, user_token, lang):
     raise PreventUpdate
 
 
+from dash import Input, Output, State, callback
+
+
+@callback(
+    Output("detection_fetch_limit", "data"),
+    Input("detection_fetch_limit_input", "value"),
+    prevent_initial_call=True,  # optional, remove if you want it to run on first load
+)
+def update_fetch_limit(value):
+    if value is None:
+        return 10  # fallback default
+    return value
+
+
 @app.callback(
     Output("available-stream-sites", "data"),
     Input("user_name", "data"),
@@ -207,19 +221,19 @@ def api_cameras_watcher(n_intervals, api_cameras, user_token):
     [
         Input("main_api_fetch_interval", "n_intervals"),
         Input("api_cameras", "data"),
-        Input("my-date-picker-single", "date"),
         Input("to_acknowledge", "data"),
         Input("unmatched_event_id_table", "data"),
+        Input("my-date-picker-single", "date"),
     ],
     [State("api_sequences", "data"), State("user_token", "data"), State("event_id_table", "data")],
     prevent_initial_call=True,
 )
 def api_watcher(
     n_intervals,
     api_cameras,
-    selected_date,
     to_acknowledge,
     unmatched_event_id_table,
+    selected_date,
     local_sequences,
     user_token,
     local_event_id_table,
@@ -285,19 +299,30 @@ def api_watcher(
             api_sequences, event_id_table = compute_overlap(
                 api_sequences, unmatched_event_table=unmatched_event_id_table
             )
+
             local_event_id_table = pd.read_json(StringIO(local_event_id_table), orient="split")
 
-        # Load local sequences safely
-        if local_sequences:
-            local_sequences_df = pd.read_json(StringIO(local_sequences), orient="split")
-        else:
-            local_sequences_df = pd.DataFrame()
+            # Load local sequences safely
+            if local_sequences:
+                local_sequences_df = pd.read_json(StringIO(local_sequences), orient="split")
+            else:
+                local_sequences_df = pd.DataFrame()
+
+            # Ensure valid DataFrames
+            if not isinstance(local_event_id_table, pd.DataFrame):
+                local_event_id_table = pd.DataFrame()
+            if not isinstance(event_id_table, pd.DataFrame):
+                event_id_table = pd.DataFrame()
+
+            # Check event condition: either empty or sequences match
+            event_condition = event_id_table.empty or (
+                "sequences" in local_event_id_table.columns
+                and "sequences" in event_id_table.columns
+                and np.array_equal(local_event_id_table["sequences"].values, event_id_table["sequences"].values)
+            )
 
-        if len(local_event_id_table) == len(event_id_table):
-            if len(event_id_table) == 0 or (
-                np.array_equal(local_event_id_table["sequences"].values, event_id_table["sequences"].values)
-            ):
-                # Skip update if nothing changed
+            # Now apply sequence comparison only if event condition is true
+            if event_condition:
                 if not local_sequences_df.empty and not api_sequences.empty:
                     if not sequences_have_changed(api_sequences, local_sequences_df):
                         logger.info("Skipping update: no significant change detected")
@@ -350,7 +375,11 @@ def update_sub_api_sequences(api_sequences, local_sub_sequences):
 
 @app.callback(
     [Output("are_detections_loaded", "data"), Output("sequence_on_display", "data"), Output("api_detections", "data")],
-    [Input("sequence_id_on_display", "data")],
+    [
+        Input("sequence_id_on_display", "data"),
+        Input("detection_fetch_limit", "data"),
+        Input("detection_fetch_desc", "value"),
+    ],
     [
         State("api_sequences", "data"),
         State("api_detections", "data"),
@@ -359,10 +388,20 @@ def update_sub_api_sequences(api_sequences, local_sub_sequences):
     ],
     prevent_initial_call=True,
 )
-def load_detections(sequence_id_on_display, api_sequences, api_detections, are_detections_loaded, user_token):
+def load_detections(
+    sequence_id_on_display,
+    detection_fetch_limit,
+    detection_fetch_desc,
+    api_sequences,
+    api_detections,
+    are_detections_loaded,
+    user_token,
+):
     if user_token is None or sequence_id_on_display is None:
         raise PreventUpdate
 
+    detection_fetch_desc = detection_fetch_desc if detection_fetch_desc else False
+
     try:
         api_sequences = pd.read_json(StringIO(api_sequences), orient="split")
         api_detections = dict(json.loads(api_detections))
@@ -378,26 +417,37 @@ def load_detections(sequence_id_on_display, api_sequences, api_detections, are_d
     sequence_on_display = pd.DataFrame().to_json(orient="split")
     client = get_client(user_token)
 
-    if sequence_id_on_display not in api_detections:
+    detection_key = f"{sequence_id_on_display}_{detection_fetch_limit}_{detection_fetch_desc}"
+
+    if detection_key not in api_detections.keys():
         try:
-            response = client.fetch_sequences_detections(sequence_id_on_display)
+            response = client.fetch_sequences_detections(
+                sequence_id=sequence_id_on_display, limit=detection_fetch_limit, desc=detection_fetch_desc
+            )
             data = response.json()
             detections = pd.DataFrame(data) if isinstance(data, list) else pd.DataFrame()
+
             if not detections.empty and "bboxes" in detections.columns:
                 detections = detections.iloc[::-1].reset_index(drop=True)
                 detections["processed_bboxes"] = detections["bboxes"].apply(process_bbox)
-            api_detections[sequence_id_on_display] = detections.to_json(orient="split")
+
+                sequence_meta = api_sequences.loc[api_sequences["id"].astype(str) == sequence_id_on_display]
+                if not sequence_meta.empty:
+                    lat = sequence_meta.iloc[0].get("lat")
+                    lon = sequence_meta.iloc[0].get("lon")
+
+                    if "created_at" in detections.columns and pd.notnull(lat) and pd.notnull(lon):
+                        detections["created_at_local"] = detections["created_at"].apply(
+                            lambda dt: convert_dt_to_local_tz(lat, lon, dt) if pd.notnull(dt) else None
+                        )
+
+            api_detections[detection_key] = detections.to_json(orient="split")
+
         except Exception as e:
             logger.error(f"Error fetching detections for {sequence_id_on_display}: {e}")
             return dash.no_update, dash.no_update, dash.no_update
 
-    sequence_on_display = api_detections[sequence_id_on_display]
-    filtered = api_sequences.loc[api_sequences["id"].astype(str) == sequence_id_on_display, "last_seen_at"]
-
-    if filtered.empty:
-        return dash.no_update, dash.no_update, dash.no_update
-
-    are_detections_loaded[sequence_id_on_display] = str(filtered.iloc[0])
+    sequence_on_display = api_detections[detection_key]
 
     return json.dumps(are_detections_loaded), sequence_on_display, json.dumps(api_detections)
 

app/callbacks/display_callbacks.py

@@ -12,6 +12,7 @@
 import boto3  # type: ignore
 import dash
 import logging_config
+import numpy as np
 import pandas as pd
 from botocore.exceptions import ClientError  # type: ignore
 from dash import Input, Output, State, ctx
@@ -198,15 +199,22 @@ def update_sequence_on_dropdown_change(selected_sequence_id):
         Output("image-slider", "min"),
         Output("slider-container", "style"),
     ],
-    [Input("image-slider", "value"), Input("sequence_on_display", "data")],
+    [
+        Input("image-slider", "value"),
+        Input("sequence_on_display", "data"),
+        Input("detection_fetch_desc", "value"),
+    ],
     [
         State("sequence-list-container", "children"),
         State("language", "data"),
-        State("alert-end-date-value", "children"),
     ],
     prevent_initial_call=True,
 )
-def update_image_and_bbox(slider_value, sequence_on_display, sequence_list, lang, alert_end_value):
+def update_image_and_bbox(slider_value, sequence_on_display, detection_fetch_desc, sequence_list, lang):
+    from io import StringIO
+
+    import pandas as pd
+
     no_alert_image_src = "./assets/images/no-alert-default.png"
     if lang == "es":
         no_alert_image_src = "./assets/images/no-alert-default-es.png"
@@ -216,8 +224,15 @@ def update_image_and_bbox(slider_value, sequence_on_display, sequence_list, lang
     if sequence_on_display.empty or not len(sequence_list):
         return no_alert_image_src, *[{"display": "none"}] * 3, 0, {}, 0, {"display": "none"}
 
-    images, boxes = zip(
-        *((alert["url"], alert["processed_bboxes"]) for _, alert in sequence_on_display.iterrows() if alert["url"]),
+    if not detection_fetch_desc:
+        sequence_on_display = sequence_on_display[::-1].reset_index(drop=True)
+
+    images, boxes, created_at_local_list = zip(
+        *(
+            (alert["url"], alert["processed_bboxes"], alert.get("created_at_local"))
+            for _, alert in sequence_on_display.iterrows()
+            if alert["url"]
+        ),
         strict=False,
     )
 
@@ -244,14 +259,15 @@ def update_image_and_bbox(slider_value, sequence_on_display, sequence_list, lang
         }
 
     try:
-        if isinstance(alert_end_value, str) and alert_end_value.strip():
-            last_time = datetime.strptime(alert_end_value.strip(), "%H:%M")
-        else:
-            raise ValueError("Empty or invalid date string")
+        latest_time = pd.to_datetime(sequence_on_display["created_at_local"].dropna().max())
     except Exception:
-        last_time = datetime.now()
+        latest_time = datetime.now()
+
+    # Compute 5 evenly spaced tick positions
+    num_marks = 5
+    tick_indices = sorted(set(int(round(i)) for i in np.linspace(0, n_images - 1, num=num_marks)))
 
-    marks = {i: (last_time - timedelta(seconds=30 * (n_images - 1 - i))).strftime("%H:%M:%S") for i in range(n_images)}
+    marks = {i: (latest_time - timedelta(seconds=30 * (n_images - 1 - i))).strftime("%H:%M:%S") for i in tick_indices}
 
     return [img_src, *bbox_styles, n_images - 1, marks, 0, {"display": "block"}]
 
@@ -541,25 +557,25 @@ def update_fire_markers(smoke_location_str, api_sequences):
         Input("confirm-non-wildfire", "n_clicks"),
         Input("cancel-confirmation", "n_clicks"),
     ],
-    [State("sequence_id_on_display", "data"), State("user_token", "data")],
+    [
+        State("sequence_id_on_display", "data"),
+        State("user_token", "data"),
+    ],
     prevent_initial_call=True,
 )
 def acknowledge_event(
     acknowledge_clicks, confirm_wildfire, confirm_non_wildfire, cancel, sequence_id_on_display, user_token
 ):
     ctx = dash.callback_context
 
-    logger.info("acknowledge_event")
-
     if not ctx.triggered:
-        raise dash.exceptions.PreventUpdate
+        raise PreventUpdate
 
     if user_token is None:
-        return dash.no_update
+        raise PreventUpdate
 
     triggered_id = ctx.triggered[0]["prop_id"].split(".")[0]
 
-    # Modal styles
     modal_visible_style = {
         "position": "fixed",
         "top": "50%",
@@ -571,29 +587,31 @@ def acknowledge_event(
     modal_hidden_style = {"display": "none"}
 
     client = get_client(user_token)
+    client.token = user_token
 
     if triggered_id == "acknowledge-button":
-        # Show the modal
-        if acknowledge_clicks > 0:
-            return modal_visible_style, dash.no_update
+        if acknowledge_clicks is None or acknowledge_clicks == 0:
+            raise PreventUpdate
+        return modal_visible_style, dash.no_update
 
     elif triggered_id == "confirm-wildfire":
-        # Send wildfire confirmation to the API
-        client.token = user_token
+        if confirm_wildfire is None or confirm_wildfire == 0:
+            raise PreventUpdate
         client.label_sequence(sequence_id_on_display, True)
         return modal_hidden_style, sequence_id_on_display
 
     elif triggered_id == "confirm-non-wildfire":
-        # Send non-wildfire confirmation to the API
-        client.token = user_token
+        if confirm_non_wildfire is None or confirm_non_wildfire == 0:
+            raise PreventUpdate
         client.label_sequence(sequence_id_on_display, False)
         return modal_hidden_style, sequence_id_on_display
 
     elif triggered_id == "cancel-confirmation":
-        # Cancel action
+        if cancel is None or cancel == 0:
+            raise PreventUpdate
         return modal_hidden_style, dash.no_update
 
-    raise dash.exceptions.PreventUpdate
+    raise PreventUpdate
 
 
 # Modal issue let's add this later
@@ -740,12 +758,15 @@ def update_datepicker(open_clicks, selected_date):
 def pick_live_stream_camera(n_clicks, azimuth, camera_label, azimuth_label):
     logger.info("pick_live_stream_camera")
 
+    if n_clicks is None or n_clicks == 0:
+        raise PreventUpdate
+
     if not camera_label or not azimuth_label:
         raise PreventUpdate
+
     try:
         cam_name, _, _ = camera_label.split(" ")
         azimuth = int(azimuth.replace("°", ""))
-        # detection_azimuth = int(azimuth_label.replace("°", "").strip()) Need azimuth refine first
     except Exception as e:
         logger.warning(f"[pick_live_stream_camera] Failed to parse camera info: {e}")
         raise PreventUpdate
@@ -1032,7 +1053,7 @@ def hide_button_callback(sub_api_sequences, sequence_id, event_id_table_json, se
         if df_sequences.empty:
             return hide_style, hide_style, hide_style
     except Exception as e:
-        print(f"[hide_button_callback] Failed to read sub_api_sequences: {e}")
+        logger.error(f"[hide_button_callback] Failed to read sub_api_sequences: {e}")
         return hide_style, hide_style, hide_style
 
     # Default: show stream & mask buttons
@@ -1054,6 +1075,6 @@ def hide_button_callback(sub_api_sequences, sequence_id, event_id_table_json, se
             if isinstance(sequences, list) and len(sequences) > 1:
                 unmatch_style = show_style
     except Exception as e:
-        print(f"[hide_button_callback] Failed to process event_id_table: {e}")
+        logger.error(f"[hide_button_callback] Failed to process event_id_table: {e}")
 
     return stream_style, mask_style, unmatch_style

app/index.py

@@ -58,8 +58,11 @@ def display_page(
     if triggered == "selected-camera-info" and selected_camera_info:
         return live_stream_layout(user_token, api_cameras, available_stream, selected_camera_info, lang=lang)
 
-    if (pathname == "/" or pathname is None) or triggered == "my-date-picker-single":
-        return homepage_layout(user_token, api_cameras, lang=lang)
+    if triggered == "my-date-picker-single":
+        return homepage_layout(user_token, api_cameras, lang=lang, descending_order=False)
+
+    if pathname in ["/", None]:
+        return homepage_layout(user_token, api_cameras, lang=lang, descending_order=True)
 
     if pathname == "/cameras-status":
         return cameras_status_layout(user_token, api_cameras, lang=lang)

app/layouts/main_layout.py

@@ -86,4 +86,5 @@ def get_main_layout():
         dcc.Store(id="selected-camera-info", storage_type="session"),
         dcc.Store(id="language", storage_type="session", data="fr"),
         dcc.Store(id="selected_event_id", storage_type="session", data=None),
+        dcc.Store(id="detection_fetch_limit", storage_type="session", data=10),
     ])