Update app.py

app.py

@@ -6,11 +6,9 @@
 # - Anomalies tab: auto-surface Sleep cases -> Admin can raise, comment, resolve (local-only).
 # - Face DB: loads ALL subfolders under ./employees (each subfolder = employee name).
 # - Salesforce: disabled (code paths retained; everything stored locally to CSV lists).
-# - PATCH 1: Do NOT show frames live; record all overlays into mp4 at source FPS and autoplay after processing.
-# - PATCH 2: CSV download buttons use in-memory bytes to avoid refresh side-effects.
 # ------------------------------------------------------------------------------------
 
-import os, io, json, math, time, tempfile, traceback, uuid, base64
+import os, io, json, math, time, tempfile, traceback, uuid
 from pathlib import Path
 from dataclasses import dataclass
 from datetime import datetime, date
@@ -27,7 +25,7 @@ ENABLE_SF = False  # 🔕 keep SF code paths but do not call API
 MAX_PREVIEW_W = 1280
 FACE_UPDATE_EVERY_N = 4
 EVENT_COOLDOWN_SEC = 1.0
-PHONE_PERSIST_N = 2           # quicker "On Phone" stabilization
+PHONE_PERSIST_N = 2           # ↓ from 3 to 2 so "On Phone" stabilizes quicker
 SLEEP_IDLE_SECONDS = 60.0
 CHECKOUT_MISS_FRAMES = 90
 
@@ -87,7 +85,6 @@ st.session_state.setdefault("attendance_rows", [])         # local CSV for atten
 st.session_state.setdefault("metric_rows", [])             # local CSV for metrics (session appends)
 st.session_state.setdefault("anomalies", [])               # anomaly tickets (local workflow)
 st.session_state.setdefault("anomaly_counter", 1)          # incremental id
-st.session_state.setdefault("last_processed_video", None)  # PATCH 1: path to processed mp4
 
 def log_ui(line, ok=True):
     col = "🟢" if ok else "🔴"
@@ -244,19 +241,18 @@ def fmt_secs_short(secs_float):
 # ------------------------- CSV helpers -------------------------
 def save_events_csv(run_id: str):
     df = st.session_state.events
-    if df.empty: return "", b""
+    if df.empty: return ""
     df = df[df["run_id"] == run_id].copy()
-    if df.empty: return "", b""
+    if df.empty: return ""
     out_path = f"/tmp/events_{run_id}.csv"
-    csv_bytes = df.to_csv(index=False).encode("utf-8")
-    Path(out_path).write_bytes(csv_bytes)
-    return out_path, csv_bytes
+    df.to_csv(out_path, index=False)
+    return out_path
 
 def save_run_summary_csv(run_id: str, site_floor: str, camera_name: str):
     df = st.session_state.events
-    if df.empty: return "", b""
+    if df.empty: return ""
     df = df[df["run_id"] == run_id].copy()
-    if df.empty: return "", b""
+    if df.empty: return ""
     counts = df.groupby(["employee","activity"]).size().unstack(fill_value=0)
     for col in ["Working","On Phone","Idle","Away","Sleep"]:
         if col not in counts.columns: counts[col] = 0
@@ -269,36 +265,32 @@ def save_run_summary_csv(run_id: str, site_floor: str, camera_name: str):
     out.insert(0,"run_id", run_id)
     out.insert(0,"date", date.today().isoformat())
     out_path = f"/tmp/run_summary_{run_id}.csv"
-    csv_bytes = out.to_csv(index=False).encode("utf-8")
-    Path(out_path).write_bytes(csv_bytes)
-    return out_path, csv_bytes
+    out.to_csv(out_path, index=False)
+    return out_path
 
-def save_attendance_csv() -> tuple[str, bytes]:
+def save_attendance_csv() -> str:
     rows = st.session_state.attendance_rows
-    if not rows: return "", b""
+    if not rows: return ""
     df = pd.DataFrame(rows)
     out_path = "/tmp/attendance_today.csv"
-    csv_bytes = df.to_csv(index=False).encode("utf-8")
-    Path(out_path).write_bytes(csv_bytes)
-    return out_path, csv_bytes
+    df.to_csv(out_path, index=False)
+    return out_path
 
-def save_metrics_csv() -> tuple[str, bytes]:
+def save_metrics_csv() -> str:
     rows = st.session_state.metric_rows
-    if not rows: return "", b""
+    if not rows: return ""
     df = pd.DataFrame(rows)
     out_path = "/tmp/metrics_today.csv"
-    csv_bytes = df.to_csv(index=False).encode("utf-8")
-    Path(out_path).write_bytes(csv_bytes)
-    return out_path, csv_bytes
+    df.to_csv(out_path, index=False)
+    return out_path
 
-def save_anomalies_csv() -> tuple[str, bytes]:
+def save_anomalies_csv() -> str:
     rows = st.session_state.anomalies
-    if not rows: return "", b""
+    if not rows: return ""
     df = pd.DataFrame(rows)
     out_path = "/tmp/anomalies_today.csv"
-    csv_bytes = df.to_csv(index=False).encode("utf-8")
-    Path(out_path).write_bytes(csv_bytes)
-    return out_path, csv_bytes
+    df.to_csv(out_path, index=False)
+    return out_path
 
 # ------------------------- “Salesforce” shims (disabled) -------------------------
 def push_events_batch(rows):
@@ -385,35 +377,6 @@ with tabs[0]:
                 })
                 log_ui(f"Anomaly opened for {name} (Sleep)", ok=False)
 
-    def _pick_video_writer(path: str, fps: float, size_wh: tuple[int,int]):
-        """Try mp4v, then avc1, then XVID (avi fallback)."""
-        w, h = size_wh
-        # Primary: mp4
-        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-        vw = cv2.VideoWriter(path, fourcc, max(fps, 1.0), (w, h))
-        if vw.isOpened():
-            return vw, path
-        # Try avc1
-        fourcc = cv2.VideoWriter_fourcc(*"avc1")
-        vw = cv2.VideoWriter(path, fourcc, max(fps, 1.0), (w, h))
-        if vw.isOpened():
-            return vw, path
-        # Fallback to avi
-        avi_path = Path(path).with_suffix(".avi").as_posix()
-        fourcc = cv2.VideoWriter_fourcc(*"XVID")
-        vw = cv2.VideoWriter(avi_path, fourcc, max(fps, 1.0), (w, h))
-        return vw, avi_path
-
-    def _autoplay_video_bytes(video_bytes: bytes):
-        """Autoplay via HTML5 video tag (muted + playsinline)."""
-        b64 = base64.b64encode(video_bytes).decode("utf-8")
-        html = f"""
-        <video controls autoplay muted playsinline style="width:100%;outline:none;border-radius:12px;">
-            <source src="data:video/mp4;base64,{b64}" type="video/mp4">
-        </video>
-        """
-        st.markdown(html, unsafe_allow_html=True)
-
     def process_video(file_or_path, conf_thres: float, fps_fraction: float, idle_motion_px: int):
         st.session_state.current_run_id = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
         run_id = st.session_state.current_run_id
@@ -442,54 +405,56 @@ with tabs[0]:
 
         src_fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
         total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        # --- PATCH 1: Prepare processed video writer (real-time based on source FPS)
+        out_video_path = "processed_output.mp4"
+        try:
+            if os.path.exists(out_video_path):
+                os.remove(out_video_path)
+        except Exception:
+            pass
+        W0 = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) or 0
+        H0 = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) or 0
+        if W0 <= 0 or H0 <= 0:
+            # Fallback: probe one frame to get size
+            ret_probe, frame_probe = cap.read()
+            if not ret_probe:
+                st.error("Failed to read video.")
+                return
+            H0, W0 = frame_probe.shape[:2]
+            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)  # rewind
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        writer = cv2.VideoWriter(out_video_path, fourcc, (src_fps if src_fps>0 else 25.0), (W0, H0))
+
         prog = st.progress(0.0)
+        out_canvas = st.empty()
         log_box = st.empty()
 
-        # PATCH 1: set up VideoWriter to record annotated frames for later autoplay
-        ret_first, first_frame = cap.read()
-        if not ret_first:
-            st.error("Could not read video.")
-            return
-        H0, W0 = first_frame.shape[:2]
-        # compute processing scale (preview downscale still used for inference only)
-        scale = 1.0
-        if W0 > MAX_PREVIEW_W:
-            scale = MAX_PREVIEW_W / W0
-        # rewind to frame 0
-        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-        # processed video path
-        out_vid_path = f"/tmp/processed_{run_id}.mp4"
-        vw, out_vid_path = _pick_video_writer(out_vid_path, src_fps, (W0, H0))
-        if not vw or not vw.isOpened():
-            st.error("Failed to open VideoWriter for processed output.")
-            return
-
         frame_no = 0
         last_face_refresh = -999
         t_last = time.time()
 
-        # while loop
         while cap.isOpened():
             ret, frame = cap.read()
             if not ret: break
             frame_no += 1
 
-            # pace to FPS (real-time)
+            # pace to FPS
             dt_target = 1.0 / (src_fps if src_fps>0 else 25.0)
             now = time.time()
             slip = dt_target - (now - t_last)
             if slip > 0: time.sleep(slip)
             t_last = time.time()
 
-            # resize for inference if needed (recording uses original full-res frame)
+            # resize preview if needed
             H, W = frame.shape[:2]
             infer = frame
+            scale = 1.0
             if W > MAX_PREVIEW_W:
+                scale = MAX_PREVIEW_W / W
                 infer = cv2.resize(frame, (int(W*scale), int(H*scale)), interpolation=cv2.INTER_AREA)
 
             def inv_box(b):
-                if infer is frame:  # no scaling
-                    return b
+                if scale == 1.0: return b
                 x1,y1,x2,y2 = b
                 inv = 1.0 / scale
                 return (int(x1*inv), int(y1*inv), int(x2*inv), int(y2*inv))
@@ -506,7 +471,7 @@ with tabs[0]:
                 face_boxes = [inv_box(b[:4]) for b in faces_rel]
                 last_face_refresh = frame_no
 
-            vis = frame.copy()  # annotated frame to be recorded
+            vis = frame.copy()
 
             # per person
             for idx, p in enumerate(persons):
@@ -550,6 +515,7 @@ with tabs[0]:
                     else:
                         if (time.time() - st.session_state.idle_start_ts[name]) >= SLEEP_IDLE_SECONDS:
                             act = "Sleep"
+                            # surface anomaly candidate
                             _open_ticket_if_sleep(name, c.get("sleep", 0.0))
                 else:
                     st.session_state.idle_start_ts[name] = time.time()
@@ -560,17 +526,18 @@ with tabs[0]:
                     c["sleep"] = c.get("sleep",0.0) + dt
 
                 # phone nanosecond timer (continuous accumulation)
-                now_ns = time.time_ns()
+                now_ns2 = time.time_ns()
                 if act == "On Phone":
                     if st.session_state.on_phone_start_ns.get(name) is None:
-                        st.session_state.on_phone_start_ns[name] = now_ns
+                        st.session_state.on_phone_start_ns[name] = now_ns2
                     else:
-                        delta = now_ns - int(st.session_state.on_phone_start_ns[name])
+                        # accumulate while active so Employees/overlay keep increasing smoothly
+                        delta = now_ns2 - int(st.session_state.on_phone_start_ns[name])
                         st.session_state.on_phone_accum_ns[name] = int(st.session_state.on_phone_accum_ns.get(name,0)) + delta
-                        st.session_state.on_phone_start_ns[name] = now_ns
+                        st.session_state.on_phone_start_ns[name] = now_ns2
                 else:
                     if st.session_state.on_phone_start_ns.get(name) is not None:
-                        st.session_state.on_phone_accum_ns[name] = int(st.session_state.on_phone_accum_ns.get(name,0)) + (now_ns - int(st.session_state.on_phone_start_ns[name]))
+                        st.session_state.on_phone_accum_ns[name] = int(st.session_state.on_phone_accum_ns.get(name,0)) + (now_ns2 - int(st.session_state.on_phone_start_ns[name]))
                         st.session_state.on_phone_start_ns[name] = None
 
                 # attendance once per run for known names
@@ -644,23 +611,27 @@ with tabs[0]:
                 push_events_batch(event_write_buffer[:30])
                 del event_write_buffer[:30]
 
-            # PATCH 1: record the annotated frame instead of showing live
-            vw.write(vis)
-
-            # progress + logs
+            # UI live preview (unchanged)
+            out_canvas.image(cv2.cvtColor(vis, cv2.COLOR_BGR2RGB), channels="RGB", use_column_width=True)
             if total>0 and frame_no % 10 == 0:
                 prog.progress(min(1.0, frame_no/total))
-            if st.session_state.logs and (frame_no % 15 == 0):
+            if st.session_state.logs:
                 log_text = "\n".join(list(st.session_state.logs)[-8:])
                 log_box.text_area("Run log", log_text, height=160, key=f"run_log_{int(time.time()*1000)}")
 
+            # --- PATCH 1: Write processed frame to output video
+            try:
+                writer.write(vis)
+            except Exception:
+                pass
+
         cap.release()
-        vw.release()
+        try:
+            writer.release()
+        except Exception:
+            pass
         prog.progress(1.0)
 
-        # store path for later (if needed)
-        st.session_state.last_processed_video = out_vid_path
-
         # flush remaining events (SF disabled – just log)
         if event_write_buffer:
             push_events_batch(event_write_buffer)
@@ -670,7 +641,7 @@ with tabs[0]:
         for emp, c in st.session_state.emp_counters.items():
             pn_ns = int(st.session_state.on_phone_accum_ns.get(emp,0))
             if st.session_state.on_phone_start_ns.get(emp) is not None:
-                pn_ns = int(st.session_state.on_phone_accum_ns.get(emp,0))
+                pn_ns = int(st.session_state.on_phone_accum_ns.get(emp,0))  # already accumulated
             metric_rows.append({
                 "As_Of_Date__c": date.today().isoformat(),
                 "Working_Sec__c": int(c.get("working",0.0)),
@@ -683,35 +654,41 @@ with tabs[0]:
             })
         push_metric_batch(metric_rows)
 
-        # CSV artifacts (PATCH 2: return bytes too)
-        ev_csv, ev_bytes   = save_events_csv(run_id)
-        sum_csv, sum_bytes = save_run_summary_csv(run_id, f"Floor {DEFAULT_FLOOR}", DEFAULT_CAMERA_ID)
-        att_csv, att_bytes = save_attendance_csv()
-        met_csv, met_bytes = save_metrics_csv()
-        an_csv, an_bytes   = save_anomalies_csv()
+        # CSV artifacts
+        ev_csv = save_events_csv(run_id)
+        sum_csv = save_run_summary_csv(run_id, f"Floor {DEFAULT_FLOOR}", DEFAULT_CAMERA_ID)
+        att_csv = save_attendance_csv()
+        met_csv = save_metrics_csv()
+        an_csv  = save_anomalies_csv()
 
         st.success(f"Processed frames: {frame_no}")
 
-        # PATCH 1: autoplay processed video
-        try:
-            video_bytes = Path(out_vid_path).read_bytes()
-            _autoplay_video_bytes(video_bytes)
-            st.download_button("Download Processed Video",
-                               data=video_bytes,
-                               file_name=Path(out_vid_path).name,
-                               mime="video/mp4",
-                               key=f"dl_vid_{run_id}")
-        except Exception as e:
-            st.warning(f"Video playback fallback. ({e})")
-            st.video(out_vid_path)
+        # --- PATCH 2: In-memory bytes for stable CSV downloads + Play button
+        c_play, c1,c2,c3,c4,c5 = st.columns(6)
 
-        # Stable CSV downloads (in-memory bytes)
-        c1,c2,c3,c4,c5 = st.columns(5)
-        if ev_bytes:   c1.download_button("Download Events CSV",    data=ev_bytes,   file_name=Path(ev_csv).name, key=f"dl_ev_{run_id}")
-        if sum_bytes:  c2.download_button("Download Summary CSV",   data=sum_bytes,  file_name=Path(sum_csv).name, key=f"dl_sum_{run_id}")
-        if att_bytes:  c3.download_button("Download Attendance CSV",data=att_bytes,  file_name=Path(att_csv).name, key=f"dl_att_{run_id}")
-        if met_bytes:  c4.download_button("Download Metrics CSV",   data=met_bytes,  file_name=Path(met_csv).name, key=f"dl_met_{run_id}")
-        if an_bytes:   c5.download_button("Download Anomalies CSV", data=an_bytes,   file_name=Path(an_csv).name, key=f"dl_an_{run_id}")
+        # Play processed video button
+        if c_play.button("Play Processed Video", key=f"play_processed_{run_id}"):
+            if os.path.exists(out_video_path):
+                st.video(out_video_path)
+            else:
+                st.warning("processed_output.mp4 not found yet.")
+
+        # Prepare bytes once to avoid re-open jitter and rerun side-effects
+        if ev_csv:
+            with open(ev_csv, "rb") as f: ev_bytes = f.read()
+            c1.download_button("Download Events CSV",   data=ev_bytes, file_name=Path(ev_csv).name, mime="text/csv", key=f"dl_evt_{run_id}")
+        if sum_csv:
+            with open(sum_csv, "rb") as f: sum_bytes = f.read()
+            c2.download_button("Download Summary CSV", data=sum_bytes, file_name=Path(sum_csv).name, mime="text/csv", key=f"dl_sum_{run_id}")
+        if att_csv:
+            with open(att_csv, "rb") as f: att_bytes = f.read()
+            c3.download_button("Download Attendance CSV", data=att_bytes, file_name=Path(att_csv).name, mime="text/csv", key=f"dl_att_{run_id}")
+        if met_csv:
+            with open(met_csv, "rb") as f: met_bytes = f.read()
+            c4.download_button("Download Metrics CSV",    data=met_bytes, file_name=Path(met_csv).name, mime="text/csv", key=f"dl_met_{run_id}")
+        if an_csv:
+            with open(an_csv, "rb") as f: an_bytes = f.read()
+            c5.download_button("Download Anomalies CSV",  data=an_bytes, file_name=Path(an_csv).name, mime="text/csv", key=f"dl_an_{run_id}")
 
     if process_btn:
         try:
@@ -759,7 +736,7 @@ with tabs[1]:
     col1, col2 = st.columns(2)
     if not emp_df.empty:
         csv_bytes = emp_df.to_csv(index=False).encode("utf-8")
-        col1.download_button("Export Employees CSV", data=csv_bytes, file_name="employees_live.csv", key="emp_export_csv")
+        col1.download_button("Export Employees CSV", data=csv_bytes, file_name="employees_live.csv", key="emp_export_btn")
 
     # Show who the face DB knows
     st.markdown("**Face DB:** " + (", ".join(sorted(face_db.keys())) if face_db else "— none —"))
@@ -775,6 +752,7 @@ with tabs[2]:
     c1,c2,c3,c4,c5 = st.columns(5)
     c1.metric("Present (unique people)", value=ev['employee'].nunique() if not ev.empty else 0)
     c2.metric("Events", value=len(ev))
+    # derive avg working/idle from metrics if present
     met_df = pd.DataFrame(st.session_state.metric_rows) if st.session_state.metric_rows else pd.DataFrame(columns=["Working_Sec__c","Idle_Us__c","On_Phones__c","Unique_Key__c"])
     if not met_df.empty:
         c3.metric("Avg Working (sec)", int(met_df["Working_Sec__c"].mean()))
@@ -832,20 +810,23 @@ with tabs[2]:
         if sel_zone != "All": dfb = dfb[dfb["zone"] == sel_zone]
         dfb = dfb.drop(columns=["d"])
         st.dataframe(dfb, use_container_width=True, hide_index=True, height=280)
-        st.download_button("Export CSV", data=dfb.to_csv(index=False).encode("utf-8"), file_name="report_builder.csv", key="rb_export")
+        st.download_button("Export CSV", data=dfb.to_csv(index=False).encode("utf-8"),
+                           file_name="report_builder.csv", key="report_builder_dl")
     else:
         st.info("Run a session to populate the report builder table.")
 
     st.divider()
     # One-click CSVs of today’s local stores
     colA, colB, colC = st.columns(3)
-    att_csv, att_bytes = save_attendance_csv()
-    met_csv, met_bytes = save_metrics_csv()
-    if att_bytes:
+    att_csv = save_attendance_csv()
+    met_csv = save_metrics_csv()
+    if att_csv:
+        with open(att_csv, "rb") as f: att_bytes = f.read()
         colA.download_button("Download Attendance CSV (today)", data=att_bytes, file_name=Path(att_csv).name, key="dl_att_today")
-    if met_bytes:
+    if met_csv:
+        with open(met_csv, "rb") as f: met_bytes = f.read()
         colB.download_button("Download Metrics CSV (today)", data=met_bytes, file_name=Path(met_csv).name, key="dl_met_today")
-    if not (att_bytes or met_bytes):
+    if not (att_csv or met_csv):
         st.info("Attendance/Metrics CSVs will show after a Live run.")
 
 # ------------------------- ANOMALIES TAB -------------------------
@@ -894,7 +875,7 @@ with tabs[3]:
         # actions
         st.subheader("Ticket actions")
         ids = [r["ticket_id"] for r in an_rows]
-        sel = st.selectbox("Select ticket", options=ids, index=0, key="an_sel_ticket")
+        sel = st.selectbox("Select ticket", options=ids, index=0)
         action_col1, action_col2 = st.columns(2)
         with action_col1:
             msg = st.text_input("Add note / employee response", "", key="an_msg")
@@ -913,9 +894,10 @@ with tabs[3]:
                         st.success("Ticket resolved")
                         break
 
-        an_csv, an_bytes = save_anomalies_csv()
-        if an_bytes:
-            st.download_button("Export Anomalies CSV", data=an_bytes, file_name=Path(an_csv).name, key="dl_an_today")
+        csv_an = save_anomalies_csv()
+        if csv_an:
+            with open(csv_an, "rb") as f: an_bytes = f.read()
+            st.download_button("Export Anomalies CSV", data=an_bytes, file_name=Path(csv_an).name, key="dl_an_today")
         st.divider()
 
         # show history