Update app.py

import streamlit as st
import pandas as pd
import networkx as nx

st.title("📅 Project Scheduler & Critical Path (Days Based)")

project_type = st.selectbox("Select Project Type", ["Building", "Bridge", "Road", "Other"])

st.markdown("### 📋 Task Details")
st.markdown("""
Each row: `TaskID, Duration (in days), Dependency, Relationship Type (FS/SS/FF/SF), Lag (optional)`
- Example: `A,5,,,`\n
- Example: `B,3,A,FS,0`\n
- Example: `C,2,A,SS,1`
""")

task_data = st.text_area("Paste your task data here:")

if st.button("🧮 Calculate Critical Path"):
tasks = {}
dependencies = []

# Parse input data
for line in task_data.strip().split("\n"):
parts = [p.strip() for p in line.split(",")]
task_id, duration = parts[0], int(parts[1])
dep = parts[2] if len(parts) > 2 and parts[2] else None
rel_type = parts[3] if len(parts) > 3 and parts[3] else "FS"
lag = int(parts[4]) if len(parts) > 4 and parts[4] else 0
tasks[task_id] = duration
if dep:
dependencies.append((dep, task_id, rel_type.upper(), lag))

# Build directed graph
G = nx.DiGraph()
for task_id in tasks:
G.add_node(task_id, duration=tasks[task_id])
for from_task, to_task, rel, lag in dependencies:
G.add_edge(from_task, to_task, type=rel, lag=lag)

# Initialize earliest and latest start/finish times
es = {} # Earliest start times
ef = {} # Earliest finish times
ls = {} # Latest start times
lf = {} # Latest finish times

# Topological order to ensure we process tasks in correct order
top_order = list(nx.topological_sort(G))

# Forward pass to calculate ES and EF
for task in top_order:
preds = list(G.predecessors(task))
if not preds:
es[task] = 0
else:
max_start = 0
for pred in preds:
edge = G.edges[pred, task]
pred_type = edge.get("type", "FS")
lag = edge.get("lag", 0)
if pred_type == "FS":
start_time = ef[pred] + lag
elif pred_type == "SS":
start_time = es[pred] + lag
elif pred_type == "FF":
start_time = ef[pred] - tasks[task] + lag
elif pred_type == "SF":
start_time = es[pred] - tasks[task] + lag
max_start = max(max_start, start_time)
es[task] = max_start
ef[task] = es[task] + tasks[task]

# Backward pass to calculate LS and LF
for task in reversed(top_order):
succs = list(G.successors(task))
if not succs:
lf[task] = ef[task]
else:
min_finish = min(ls[succ] for succ in succs)
lf[task] = min_finish
ls[task] = lf[task] - tasks[task]

# Critical path calculation: Task is critical if ES == LS
critical_path = [t for t in top_order if es[t] == ls[t]]

st.success(f"Critical Path: {' ➝ '.join(critical_path)}")
st.info(f"Total Project Duration: {max(ef.values())} days")

app.py

@@ -1,112 +1,4 @@
-import streamlit as st
-import pandas as pd
-import networkx as nx
-import plotly.figure_factory as ff
 
-st.title("📅 Project Scheduler & Critical Path (Days Based)")
-
-project_type = st.selectbox("Select Project Type", ["Building", "Bridge", "Road", "Other"])
-
-st.markdown("### 📋 Task Details")
-st.markdown("""
-Each row: `TaskID, Duration (in days), Dependency, Relationship Type (FS/SS/FF/SF), Lag (optional)`
-- Example: `A,5,,,`\n
-- Example: `B,3,A,FS,0`\n
-- Example: `C,2,A,SS,1`
-""")
-
-task_data = st.text_area("Paste your task data here:")
-
-if st.button("🧮 Calculate Critical Path"):
-    tasks = {}
-    dependencies = []
-
-    for line in task_data.strip().split("\n"):
-        parts = [p.strip() for p in line.split(",")]
-        task_id, duration = parts[0], int(parts[1])
-        dep = parts[2] if len(parts) > 2 and parts[2] else None
-        rel_type = parts[3] if len(parts) > 3 and parts[3] else "FS"
-        lag = int(parts[4]) if len(parts) > 4 and parts[4] else 0
-        tasks[task_id] = duration
-        if dep:
-            dependencies.append((dep, task_id, rel_type.upper(), lag))
-
-    # Build graph
-    G = nx.DiGraph()
-    for task_id in tasks:
-        G.add_node(task_id, duration=tasks[task_id])
-    for from_task, to_task, rel, lag in dependencies:
-        G.add_edge(from_task, to_task, type=rel, lag=lag)
-
-    # CPM calculation (simplified for FS and SS, other types handled properly now)
-    es = {}
-    ef = {}
-    top_order = list(nx.topological_sort(G))
-
-    for task in top_order:
-        preds = list(G.predecessors(task))
-        if not preds:
-            es[task] = 0
-        else:
-            max_start = 0
-            for pred in preds:
-                edge = G.edges[pred, task]
-                pred_type = edge.get("type", "FS")
-                lag = edge.get("lag", 0)
-                pred_duration = G.nodes[pred]["duration"]
-                if pred_type == "FS":
-                    start_time = ef[pred] + lag
-                elif pred_type == "SS":
-                    start_time = es[pred] + lag
-                elif pred_type == "FF":
-                    start_time = ef[pred] - tasks[task] + lag
-                elif pred_type == "SF":
-                    start_time = es[pred] - tasks[task] + lag
-                else:
-                    start_time = ef[pred] + lag
-                max_start = max(max_start, start_time)
-            es[task] = max_start
-        ef[task] = es[task] + tasks[task]
-
-    # Backward pass
-    lf = {}
-    ls = {}
-    for task in reversed(top_order):
-        succs = list(G.successors(task))
-        if not succs:
-            lf[task] = ef[task]
-        else:
-            min_finish = min(ls[succ] for succ in succs)
-            lf[task] = min_finish
-        ls[task] = lf[task] - tasks[task]
-
-    critical_path = [t for t in top_order if es[t] == ls[t]]
-
-    st.success(f"Critical Path: {' ➝ '.join(critical_path)}")
-    st.info(f"Total Project Duration: {max(ef.values())} days")
-
-    # Gantt chart (adjusted to handle display properly)
-    df = pd.DataFrame([
-        {
-            "Task": t,
-            "Start": f"Day {es[t]}",
-            "Finish": f"Day {ef[t]}",
-            "Start_day": es[t],
-            "Finish_day": ef[t],
-            "Resource": "Critical" if t in critical_path else "Non-Critical"
-        }
-        for t in top_order
-    ])
-
-    fig = ff.create_gantt(
-        df,
-        index_col="Resource",
-        show_colorbar=True,
-        group_tasks=True,
-        showgrid_x=True,
-        showgrid_y=True
-    )
-    st.plotly_chart(fig, use_container_width=True)