Spaces:

yusiff
/

DashBorad

Sleeping

App Files Files Community

yusiff commited on Oct 19, 2025

Commit

68178a7

verified ·

1 Parent(s): 61ff43d

Upload 4 files

Browse files

Files changed (4) hide show

__pycache__/app.cpython-310.pyc +0 -0
app.py +422 -0
data.csv +6 -0
requirements.txt +5 -0

__pycache__/app.cpython-310.pyc ADDED Viewed

Binary file (15.2 kB). View file

app.py ADDED Viewed

	@@ -0,0 +1,422 @@

+# app.py
+"""
+Run:
+    uvicorn app:app --reload --port 8000
+This app reads data.csv (expected columns below), computes metrics and serves:
+- / : HTML dashboard (JS + Chart.js)
+- /api/tasks : JSON data for charts
+- /report/pdf : PDF export
+- /report/excel : Excel export
+Expected CSV columns (case sensitive):
+Task ID,Task Name,Client,Phase,Value,Start Time,End Time,Duration (mins)
+If Duration (mins) is missing, the app will compute it using Start Time and End Time.
+Date format is flexible (pandas.parse).
+"""
+import io
+import math
+from fastapi import FastAPI, Query
+from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
+from reportlab.lib.pagesizes import A4
+from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
+from reportlab.lib import colors
+from reportlab.lib.styles import getSampleStyleSheet
+from openpyxl import Workbook
+from datetime import datetime
+import pandas as pd
+app = FastAPI(title="Task Phase Dashboard (CSV)")
+CSV_PATH = "data.csv"  # file should be in the same folder as app.py
+# Simple HTML template (English labels). Uses Chart.js from CDN.
+HTML_TEMPLATE = """<!doctype html>
+<html lang='en'>
+<head>
+  <meta charset='utf-8'>
+  <title>Task Phase Dashboard</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <script src='https://cdn.tailwindcss.com'></script>
+  <script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
+</head>
+<body class='bg-gray-50 text-left font-sans p-6'>
+  <div class='max-w-7xl mx-auto bg-white shadow-lg rounded-2xl p-6'>
+    <h2 class='text-2xl font-bold text-sky-600 mb-4 text-center'>📊 Task Phase Dashboard (CSV)</h2>
+    <div class='flex flex-wrap gap-4 items-center justify-between mb-4'>
+      <div class='flex gap-2 items-center'>
+        <label class='text-sm'>Client:</label>
+        <select id='filterClient' onchange='load()' class='px-2 py-1 border rounded'></select>
+        <label class='text-sm'>Phase:</label>
+        <select id='filterPhase' onchange='load()' class='px-2 py-1 border rounded'></select>
+        <button onclick='resetFilters()' class='ml-2 bg-gray-200 px-3 py-1 rounded'>Reset</button>
+      </div>
+      <div class='space-x-2'>
+        <a href='/report/pdf' target='_blank' class='bg-green-500 hover:bg-green-600 text-white rounded-lg px-4 py-2 transition'>📄 Export PDF</a>
+        <a href='/report/excel' target='_blank' class='bg-yellow-500 hover:bg-yellow-600 text-white rounded-lg px-4 py-2 transition'>📊 Export Excel</a>
+      </div>
+    </div>
+    <div class='grid grid-cols-1 md:grid-cols-3 gap-4 mb-6'>
+      <div class='p-4 bg-gray-100 rounded'>
+        <div class='text-sm text-gray-600'>Total tasks</div>
+        <div id='totalCount' class='text-2xl font-bold'>—</div>
+      </div>
+      <div class='p-4 bg-gray-100 rounded'>
+        <div class='text-sm text-gray-600'>Completed</div>
+        <div id='doneCount' class='text-2xl font-bold'>—</div>
+      </div>
+      <div class='p-4 bg-gray-100 rounded'>
+        <div class='text-sm text-gray-600'>Avg Duration (mins)</div>
+        <div id='avgDuration' class='text-2xl font-bold'>—</div>
+      </div>
+    </div>
+    <div class='grid grid-cols-1 lg:grid-cols-2 gap-6'>
+      <div class='p-4 bg-white rounded shadow'>
+        <h3 class='font-semibold mb-2'>Tasks per Client</h3>
+        <canvas id='clientsBar' height='250'></canvas>
+      </div>
+      <div class='p-4 bg-white rounded shadow'>
+        <h3 class='font-semibold mb-2'>Avg Duration per Client (mins)</h3>
+        <canvas id='avgBar' height='250'></canvas>
+      </div>
+      <div class='p-4 bg-white rounded shadow'>
+        <h3 class='font-semibold mb-2'>Value Distribution</h3>
+        <canvas id='valuePie' height='250'></canvas>
+      </div>
+      <div class='p-4 bg-white rounded shadow'>
+        <h3 class='font-semibold mb-2'>Tasks Over Time (by start date)</h3>
+        <canvas id='timeline' height='250'></canvas>
+      </div>
+      <div class='p-4 bg-white rounded shadow col-span-1 lg:col-span-2'>
+        <h3 class='font-semibold mb-2'>Task List</h3>
+        <div class='overflow-x-auto'>
+          <table class='min-w-full border text-sm'>
+            <thead class='bg-slate-100'>
+              <tr>
+                <th class='p-2'>Task Name</th>
+                <th class='p-2'>Client</th>
+                <th class='p-2'>Phase</th>
+                <th class='p-2'>Value</th>
+                <th class='p-2'>Duration (mins)</th>
+                <th class='p-2'>Start</th>
+                <th class='p-2'>End</th>
+                <th class='p-2'>Delayed</th>
+              </tr>
+            </thead>
+            <tbody id='taskTable'></tbody>
+          </table>
+        </div>
+      </div>
+    </div>
+  </div>
+<script>
+async function load(){
+  const client = document.getElementById('filterClient').value || '';
+  const phase = document.getElementById('filterPhase').value || '';
+  const params = new URLSearchParams();
+  if(client) params.set('client', client);
+  if(phase) params.set('phase', phase);
+  const res = await fetch('/api/tasks?' + params.toString());
+  const d = await res.json();
+  document.getElementById('totalCount').innerText = d.total_count;
+  document.getElementById('doneCount').innerText = d.done_count + ' (' + d.progress_percent.toFixed(1) + '%)';
+  document.getElementById('avgDuration').innerText = d.avg_duration.toFixed(1) + ' mins';
+  // populate filters if empty
+  const clientSel = document.getElementById('filterClient');
+  if(clientSel.options.length <= 1){
+    clientSel.innerHTML = '<option value=\"\">All</option>';
+    d.clients.forEach(c => {
+      const o = document.createElement('option'); o.value = c; o.text = c; clientSel.appendChild(o);
+    });
+  }
+  const phaseSel = document.getElementById('filterPhase');
+  if(phaseSel.options.length <= 1){
+    phaseSel.innerHTML = '<option value=\"\">All</option>';
+    d.phases.forEach(p => {
+      const o = document.createElement('option'); o.value = p; o.text = p; phaseSel.appendChild(o);
+    });
+  }
+  // task table
+  const tbody = document.getElementById('taskTable'); tbody.innerHTML = '';
+  d.tasks.forEach(t => {
+    const r = document.createElement('tr');
+    r.className = 'border-b';
+    r.innerHTML = `<td class='p-2'>${t['Task Name']}</td>
+                   <td class='p-2'>${t.Client}</td>
+                   <td class='p-2'>${t.Phase}</td>
+                   <td class='p-2'>${t.Value}</td>
+                   <td class='p-2'>${t['Duration (mins)']}</td>
+                   <td class='p-2'>${t['Start Time']}</td>
+                   <td class='p-2'>${t['End Time']}</td>
+                   <td class='p-2'>${t.delayed ? 'Yes' : 'No'}</td>`;
+    tbody.appendChild(r);
+  });
+  // charts
+  const clientsLabels = d.clients;
+  const clientsCounts = d.client_counts;
+  const avgDurations = d.client_avg_duration;
+  // destroy existing charts if present
+  if(window.clientsChart){ window.clientsChart.destroy(); }
+  if(window.avgChart){ window.avgChart.destroy(); }
+  if(window.valueChart){ window.valueChart.destroy(); }
+  if(window.timeChart){ window.timeChart.destroy(); }
+  const ctx1 = document.getElementById('clientsBar').getContext('2d');
+  window.clientsChart = new Chart(ctx1, {
+    type: 'bar',
+    data: { labels: clientsLabels, datasets: [{ label: 'Tasks', data: clientsCounts, backgroundColor: '#3B82F6' }]},
+    options: { responsive:true, plugins:{legend:{display:false}}, scales:{y:{beginAtZero:true}}}
+  });
+  const ctx2 = document.getElementById('avgBar').getContext('2d');
+  window.avgChart = new Chart(ctx2, {
+    type: 'bar',
+    data: { labels: clientsLabels, datasets: [{ label: 'Avg Duration (mins)', data: avgDurations, backgroundColor: '#10B981' }]},
+    options: { indexAxis: 'y', responsive:true, plugins:{legend:{display:false}} }
+  });
+  const ctx3 = document.getElementById('valuePie').getContext('2d');
+  window.valueChart = new Chart(ctx3, {
+    type: 'pie',
+    data: { labels: d.values_labels, datasets: [{ data: d.values_counts }]},
+    options: { responsive:true }
+  });
+  const ctx4 = document.getElementById('timeline').getContext('2d');
+  window.timeChart = new Chart(ctx4, {
+    type: 'line',
+    data: { labels: d.timeline.labels, datasets: [{ label: 'Tasks started', data: d.timeline.counts, fill:true, tension:0.3 }]},
+    options: { responsive:true, scales:{y:{beginAtZero:true}}}
+  });
+}
+function resetFilters(){
+  document.getElementById('filterClient').value = '';
+  document.getElementById('filterPhase').value = '';
+  load();
+}
+load();
+setInterval(load, 5*60*1000);
+</script>
+</body>
+</html>
+"""
+########### Data processing utilities ###########
+def read_and_prepare(csv_path=CSV_PATH):
+    """
+    Reads CSV and returns a DataFrame with normalized columns and derived fields:
+    - Duration (mins) ensured
+    - Start Time & End Time parsed to datetimes
+    - delayed: True if Duration > mean + std (sensible delay detector)
+    - considered 'done' if Value contains APPROVED/DONE/COMPLETED (case-insensitive)
+    """
+    df = pd.read_csv(csv_path, dtype=str).fillna("")
+    # Ensure expected columns exist
+    expected_cols = ["Task ID","Task Name","Client","Phase","Value","Start Time","End Time","Duration (mins)"]
+    for c in expected_cols:
+        if c not in df.columns:
+            df[c] = ""
+    # parse datetimes
+    def try_parse(s):
+        try:
+            return pd.to_datetime(s, errors="coerce")
+        except Exception:
+            return pd.NaT
+    df["Start_dt"] = df["Start Time"].apply(try_parse)
+    df["End_dt"] = df["End Time"].apply(try_parse)
+    # Duration numeric: if blank try to compute from datetimes
+    def duration_minutes(row):
+        val = row.get("Duration (mins)")
+        try:
+            if val is not None and str(val).strip() != "":
+                return float(str(val).strip())
+        except:
+            pass
+        s = row.get("Start_dt")
+        e = row.get("End_dt")
+        if pd.notna(s) and pd.notna(e):
+            return (e - s).total_seconds() / 60.0
+        return float("nan")
+    df["Duration (mins)"] = df.apply(duration_minutes, axis=1).astype(float)
+    # detect 'done' using keywords in Value or Phase (case-insensitive)
+    done_keywords = ["APPROVED", "DONE", "COMPLETED", "DELIVERED"]
+    df["is_done"] = df["Value"].str.upper().apply(lambda v: any(k in v for k in done_keywords))
+    # delayed detection: mark as delayed if duration > mean + std (per Phase could be better)
+    mean = df["Duration (mins)"].mean(skipna=True)
+    std = df["Duration (mins)"].std(skipna=True) if not math.isnan(mean) else 0
+    threshold = (mean + std) if not math.isnan(mean) else None
+    def detect_delayed(dur):
+        if dur is None or pd.isna(dur):
+            return False
+        if threshold is None:
+            return False
+        return dur > threshold
+    df["delayed"] = df["Duration (mins)"].apply(detect_delayed)
+    # prepare a start_date string for timeline grouping (YYYY-MM-DD)
+    df["start_date"] = df["Start_dt"].dt.date.astype(str).fillna("unknown")
+    return df
+def build_response(df, filter_client=None, filter_phase=None):
+    # apply filters
+    dff = df.copy()
+    if filter_client:
+        dff = dff[dff["Client"] == filter_client]
+    if filter_phase:
+        dff = dff[dff["Phase"] == filter_phase]
+    total_count = len(dff)
+    done_count = int(dff["is_done"].sum())
+    progress_percent = (done_count / total_count * 100) if total_count else 0
+    avg_duration = float(dff["Duration (mins)"].mean(skipna=True) or 0)
+    # Tasks per client
+    client_counts_series = dff["Client"].value_counts()
+    clients = list(client_counts_series.index)
+    client_counts = [int(x) for x in client_counts_series.values]
+    # Avg duration per client
+    client_avg = dff.groupby("Client")["Duration (mins)"].mean().reindex(clients).fillna(0).tolist()
+    # Value distribution
+    values_counts_series = dff["Value"].value_counts()
+    values_labels = list(values_counts_series.index)
+    values_counts = [int(x) for x in values_counts_series.values]
+    # timeline (by start_date) sorted
+    timeline_series = dff.groupby("start_date").size().sort_index()
+    timeline_labels = list(timeline_series.index)
+    timeline_counts = [int(x) for x in timeline_series.values]
+    # prepare tasks list (limit to first 1000 for payload safety)
+    tasks = dff[["Task ID","Task Name","Client","Phase","Value","Start Time","End Time","Duration (mins)","delayed"]].fillna("").to_dict(orient="records")
+    # unique lists for filters
+    clients_all = sorted(df["Client"].unique().tolist())
+    phases_all = sorted(df["Phase"].unique().tolist())
+    resp = {
+        "total_count": total_count,
+        "done_count": done_count,
+        "progress_percent": progress_percent,
+        "avg_duration": avg_duration,
+        "clients": clients_all,
+        "phases": phases_all,
+        "clients_filtered": clients,
+        "client_counts": client_counts,
+        "client_avg_duration": [round(x or 0, 1) for x in client_avg],
+        "values_labels": values_labels,
+        "values_counts": values_counts,
+        "timeline": {"labels": timeline_labels, "counts": timeline_counts},
+        "tasks": tasks
+    }
+    return resp
+########### End utilities ###########
+@app.get("/", response_class=HTMLResponse)
+def index():
+    return HTML_TEMPLATE
+@app.get("/api/tasks")
+def api_tasks(client: str = Query(None), phase: str = Query(None)):
+    df = read_and_prepare()
+    resp = build_response(df, filter_client=client, filter_phase=phase)
+    return JSONResponse(resp)
+@app.get("/report/pdf")
+def report_pdf():
+    df = read_and_prepare()
+    resp = build_response(df)
+    buffer = io.BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=A4)
+    styles = getSampleStyleSheet()
+    elements = [Paragraph('Task Phase Report', styles['Title']), Spacer(1, 8)]
+    elements.append(Paragraph(f"Total tasks: {resp['total_count']}", styles['Normal']))
+    elements.append(Paragraph(f"Completed: {resp['done_count']} ({resp['progress_percent']:.1f}%)", styles['Normal']))
+    elements.append(Paragraph(f"Average duration (mins): {resp['avg_duration']:.1f}", styles['Normal']))
+    elements.append(Spacer(1, 12))
+    # add table head
+    data_table = [["Task Name", "Client", "Phase", "Value", "Duration (mins)", "Start", "End", "Delayed"]]
+    for row in resp['tasks'][:200]:  # limit rows in pdf
+        data_table.append([
+            row.get("Task Name", ""),
+            row.get("Client", ""),
+            row.get("Phase", ""),
+            row.get("Value", ""),
+            f"{row.get('Duration (mins)', ''):.1f}" if isinstance(row.get('Duration (mins)'), (int, float)) else row.get('Duration (mins)', ''),
+            row.get("Start Time", ""),
+            row.get("End Time", ""),
+            "Yes" if row.get("delayed") else "No"
+        ])
+    table = Table(data_table, repeatRows=1, colWidths=[80,70,60,70,60,80,80,45])
+    table.setStyle(TableStyle([
+        ('BACKGROUND',(0,0),(-1,0),colors.lightgrey),
+        ('GRID',(0,0),(-1,-1),0.25,colors.grey),
+        ('ALIGN',(0,0),(-1,-1),'LEFT'),
+        ('FONT',(0,0),(-1,0),'Helvetica-Bold')
+    ]))
+    elements.append(table)
+    doc.build(elements)
+    buffer.seek(0)
+    return StreamingResponse(buffer, media_type='application/pdf',
+                             headers={'Content-Disposition':'attachment; filename="task_phase_report.pdf"'})
+@app.get("/report/excel")
+def report_excel():
+    df = read_and_prepare()
+    resp = build_response(df)
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "Task Report"
+    headers = ["Task ID","Task Name","Client","Phase","Value","Duration (mins)","Start Time","End Time","Delayed"]
+    ws.append(headers)
+    for row in resp['tasks']:
+        ws.append([
+            row.get("Task ID",""),
+            row.get("Task Name",""),
+            row.get("Client",""),
+            row.get("Phase",""),
+            row.get("Value",""),
+            row.get("Duration (mins)",""),
+            row.get("Start Time",""),
+            row.get("End Time",""),
+            "Yes" if row.get("delayed") else "No"
+        ])
+    buf = io.BytesIO()
+    wb.save(buf)
+    buf.seek(0)
+    return StreamingResponse(buf, media_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+                             headers={'Content-Disposition':'attachment; filename="task_phase_report.xlsx"'})

data.csv ADDED Viewed

	@@ -0,0 +1,6 @@

+Task ID,Task Name,Client,Phase,Value,Start Time,End Time,Duration (min)
+86euc18fu,abdelrahman - tt,Ashkal,Creative Stage,Blocking,8/3/2025 23:59,8/4/2025 0:06,7
+86euc18fk,abdelrahman - kk,Ashkal,Creative Stage,copywriting,8/3/2025 23:55,8/4/2025 0:06,12
+86euc18fs,abdelrahman - ss,Ashkal,Creative Stage,creative,8/3/2025 23:50,8/4/2025 0:06,17
+86euc18fp,abdelrahman - hh,youssef,copy stage,creative,8/3/2025 23:50,8/5/2025 0:06,480
+86euc18f4,yossef,mohamed,image phase,clinet approved,10/6/2025 22:50,11/7/2025 23:50,9900

requirements.txt ADDED Viewed

	@@ -0,0 +1,5 @@

+fastapi==0.111.0
+uvicorn[standard]==0.24.0
+pandas==2.1.1
+openpyxl==3.1.3
+reportlab==4.1.3