Upload folder using huggingface_hub

app.py

@@ -1,226 +1 @@
-import pandas as pd
-import numpy as np
-from datetime import datetime, date, time
-from pathlib import Path
-
-# ===================== USER CONFIG =====================
-INPUT_XLSX  = "data.xlsx"        # your input file
-OUTPUT_XLSX = "ot_summary.xlsx"  # output path
-
-# If your headers differ, you can set them here (case-insensitive). Otherwise auto-detect.
-EMPLOYEE_COL = None   # e.g., "employee_id"
-DATE_COL     = None   # e.g., "date"
-TIME_COL     = None   # e.g., "time"
-EVENT_COL    = None   # e.g., "status" (values like P10/P20), or leave None to auto-detect
-
-# Policy:
-#  - Baseline cutoff: 17:00 before 2025-07-07; 17:30 from 2025-07-07
-#  - Case 4 (virtual check-in): 17:30 before 2025-07-07; 18:00 from 2025-07-07
-POLICY_CHANGE    = date(2025, 7, 7)
-BASELINE_BEFORE  = time(17, 0)
-BASELINE_AFTER   = time(17, 30)
-VIRTUAL_BEFORE   = time(17, 30)
-VIRTUAL_AFTER    = time(18, 0)
-# =======================================================
-
-# ----------------- helpers -----------------
-def parse_yyyymmdd(s):
-    s = str(s).strip()
-    for fmt in ("%Y%m%d", "%Y-%m-%d", "%d/%m/%Y", "%m/%d/%Y"):
-        try:
-            return datetime.strptime(s, fmt).date()
-        except Exception:
-            pass
-    return pd.NaT
-
-def parse_hms(s):
-    """
-    Accept 'HH:MM[:SS]', 'HHMM', 'HHMMSS', or 5-digit like '82547' -> 08:25:47.
-    """
-    s = str(s).strip()
-    if s.isdigit():
-        s = s.zfill(6)[:6]  # left-pad to 6 digits and cap at 6
-        hh, mm, ss = s[:2], s[2:4], s[4:6]
-        try:
-            return time(int(hh), int(mm), int(ss))
-        except Exception:
-            return pd.NaT
-    for fmt in ("%H:%M:%S", "%H:%M"):
-        try:
-            return datetime.strptime(s, fmt).time()
-        except Exception:
-            pass
-    return pd.NaT
-
-def combine_dt(d, t):
-    if pd.isna(d) or pd.isna(t):
-        return pd.NaT
-    return datetime.combine(d, t)
-
-def is_from_policy(d):
-    return (not pd.isna(d)) and (d >= POLICY_CHANGE)
-
-def baseline_cutoff_time(d):
-    return BASELINE_AFTER if is_from_policy(d) else BASELINE_BEFORE
-
-def virtual_checkin_time(d):
-    return VIRTUAL_AFTER if is_from_policy(d) else VIRTUAL_BEFORE
-
-IN_TOKENS  = {"P10", "IN", "INN", "CHECKIN", "CHECK-IN"}
-OUT_TOKENS = {"P20", "OUT", "CHECKOUT", "CHECK-OUT"}
-
-def detect_event_token(v):
-    u = str(v).upper()
-    is_in  = any(tok == u or tok in u for tok in IN_TOKENS)
-    is_out = any(tok == u or tok in u for tok in OUT_TOKENS)
-    if is_in and not is_out:
-        return "in"
-    if is_out and not is_in:
-        return "out"
-    return np.nan
-
-def format_unique_times(ts_series):
-    uniq = sorted({t.strftime("%H:%M:%S") for t in ts_series.dropna()})
-    return ", ".join(uniq)
-
-# ----------------- load & normalize -----------------
-src = pd.read_excel(INPUT_XLSX, dtype=str)
-src.columns = [str(c).strip().lower() for c in src.columns]
-
-def find_col(candidates, fallback=None):
-    for col in src.columns:
-        for pat in candidates:
-            if pat in col:
-                return col
-    return fallback
-
-emp_col  = (EMPLOYEE_COL.lower() if EMPLOYEE_COL else None) or find_col(["emp", "employee", "staff", "id", "person"], src.columns[0] if len(src.columns)>0 else None)
-date_col = (DATE_COL.lower()     if DATE_COL     else None) or find_col(["date", "yyyymmdd", "ngay"], src.columns[1] if len(src.columns)>1 else None)
-time_col = (TIME_COL.lower()     if TIME_COL     else None) or find_col(["time", "gio", "hh", "clock"], src.columns[2] if len(src.columns)>2 else None)
-
-# try to guess a P10/P20 column if not specified
-if EVENT_COL and EVENT_COL.lower() in src.columns:
-    evt_col = EVENT_COL.lower()
-else:
-    evt_col = None
-    for c in src.columns:
-        vals = src[c].astype(str).str.upper()
-        if vals.isin(["P10","P20"]).any() or vals.str.contains(r"\bP10\b|\bP20\b", regex=True).any():
-            evt_col = c
-            break
-
-if emp_col not in src.columns or date_col not in src.columns or time_col not in src.columns:
-    raise ValueError(f"Could not find expected columns. Found: {list(src.columns)}")
-
-work = src.copy()
-work["__emp"]  = work[emp_col].astype(str).str.strip()
-work["__date"] = work[date_col].apply(parse_yyyymmdd)
-work["__time"] = work[time_col].apply(parse_hms)
-work["__ts"]   = [combine_dt(d, t) for d, t in zip(work["__date"], work["__time"])]
-
-# detect in/out (prefer dedicated event column; otherwise scan)
-if evt_col:
-    work["__event"] = work[evt_col].apply(detect_event_token)
-else:
-    def scan_row(row):
-        for c in row.index:
-            ev = detect_event_token(row[c])
-            if pd.notna(ev):
-                return ev
-        return np.nan
-    work["__event"] = work.apply(scan_row, axis=1)
-
-# build baseline & virtual cutoffs
-work["__baseline_t"] = work["__date"].apply(baseline_cutoff_time)
-work["__baseline_dt"] = [combine_dt(d, t) for d, t in zip(work["__date"], work["__baseline_t"])]
-work["__virtual_t"]  = work["__date"].apply(virtual_checkin_time)
-work["__virtual_dt"] = [combine_dt(d, t) for d, t in zip(work["__date"], work["__virtual_t"])]
-
-# ----------------- compute OT per employee/date -----------------
-rows = []
-for (emp, d), full_day in work.groupby(["__emp", "__date"], sort=True):
-    if pd.isna(d):
-        continue
-
-    # Sort all events of the day
-    full_day = full_day.sort_values("__ts")
-
-    baseline_dt = full_day["__baseline_dt"].iloc[0]
-    virtual_dt  = full_day["__virtual_dt"].iloc[0]
-
-    # Determine if the person was already inside at the cutoff:
-    pre = full_day[full_day["__ts"] < baseline_dt]
-    if not pre.empty:
-        last_pre_event = pre.iloc[-1]["__event"]
-        inside_at_cutoff = (last_pre_event == "in")
-    else:
-        inside_at_cutoff = False
-
-    # Consider only events at/after the baseline cutoff for outputs
-    after = full_day[full_day["__ts"] >= baseline_dt].copy()
-
-    # Unique in/out time strings (AFTER cutoff) for the report
-    ins_after  = after.loc[after["__event"].eq("in"), "__ts"]
-    outs_after = after.loc[after["__event"].eq("out"), "__ts"]
-    in_times_str  = format_unique_times(ins_after)
-    out_times_str = format_unique_times(outs_after)
-
-    # Compute OT per policy
-    code = ""
-    ot_hours = np.nan
-
-    if len(ins_after) > 0 and len(outs_after) > 0:
-        # Case 1: both in and out after cutoff → earliest IN vs latest OUT
-        earliest_in = ins_after.min()
-        latest_out  = outs_after.max()
-        if pd.notna(earliest_in) and pd.notna(latest_out) and latest_out >= earliest_in:
-            ot_hours = (latest_out - earliest_in).total_seconds() / 3600.0
-        else:
-            code = "alert"
-
-    elif len(ins_after) == 0 and len(outs_after) > 0:
-        # Case 2 or Case 4:
-        # If they were already inside at the cutoff → Case 4 (use virtual check-in)
-        # Else → Case 2 (use baseline)
-        start_dt = virtual_dt if inside_at_cutoff else baseline_dt
-        latest_out = outs_after.max()
-        if pd.notna(latest_out) and latest_out >= start_dt:
-            ot_hours = (latest_out - start_dt).total_seconds() / 3600.0
-        else:
-            ot_hours = 0.0  # guarded by baseline filter; keep 0 if anomalous
-
-    elif len(ins_after) > 0 and len(outs_after) == 0:
-        # Case 3: has IN but no OUT after cutoff
-        code = "alert"
-
-    else:
-        # No events after cutoff → nothing to report
-        continue
-
-    ot_hours = round(float(ot_hours), 2) if pd.notna(ot_hours) else np.nan
-
-    rows.append({
-        "employee_id": emp,
-        "date": d.strftime("%Y%m%d"),
-        "ot_hours": ot_hours,
-        "code": code,
-        "in_times": in_times_str,
-        "out_times": out_times_str
-    })
-
-res = pd.DataFrame(rows, columns=["employee_id","date","ot_hours","code","in_times","out_times"])
-if not res.empty:
-    res = res.sort_values(by=["employee_id","date"]).reset_index(drop=True)
-
-# ----------------- write Excel (Colab-friendly) -----------------
-try:
-    import xlsxwriter  # noqa: F401
-    engine = "xlsxwriter"
-except Exception:
-    engine = "openpyxl"  # available by default in Colab
-
-with pd.ExcelWriter(OUTPUT_XLSX, engine=engine) as w:
-    res.to_excel(w, index=False, sheet_name="OT")
-
-print(f"Done. Wrote: {Path(OUTPUT_XLSX).resolve()}")
-display(res.head(50))
+<PASTE THE WHOLE app.py CONTENT HERE>

requirements.txt

@@ -1,5 +1,5 @@
-gradio>=4.29.0,<5
-pandas>=2.0.0
-numpy>=1.24.0
-openpyxl>=3.1.0
-XlsxWriter>=3.1.0
+gradio>=4.29.0,<5
+pandas>=2.0.0
+numpy>=1.24.0
+openpyxl>=3.1.0
+XlsxWriter>=3.1.0