refactor: add comprehensive type hints throughout codebase

Added type hints to all functions in app.py, schedule.py, and test_app.py
for better IDE support and static type checking. Includes complex generic
types for constraint solving functions and proper Gradio component typing.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -4,20 +4,21 @@ import re
 from collections import defaultdict
 from ortools.sat.python import cp_model
 from datetime import datetime, timedelta
+from typing import Dict, List, Tuple, Optional, Union, Any
 
 import pandas
 
 
-def normalize_task_name(task):
+def normalize_task_name(task: str) -> str:
     """Normalize task name to lowercase for consistent comparison."""
     return task.strip().lower().replace(" ", "_")
 
 
-def display_task_name(task):
+def display_task_name(task: str) -> str:
     return task
 
 
-def parse_requirements(requirements):
+def parse_requirements(requirements: List[str]) -> Tuple[Dict[str, List[str]], List[str], Dict[str, str]]:
     """Parse requirements list into dependency graph."""
     dependencies = defaultdict(list)
     all_tasks = set()
@@ -44,7 +45,7 @@ def parse_requirements(requirements):
     return dependencies, list(all_tasks), original_names
 
 
-def solve_all_tasks(dependencies, all_tasks):
+def solve_all_tasks(dependencies: Dict[str, List[str]], all_tasks: List[str]) -> Optional[List[str]]:
     """Try to schedule all tasks (works if DAG)."""
     model = cp_model.CpModel()
     n_tasks = len(all_tasks)
@@ -71,7 +72,7 @@ def solve_all_tasks(dependencies, all_tasks):
     return None
 
 
-def solve_maximum_subset(dependencies, all_tasks):
+def solve_maximum_subset(dependencies: Dict[str, List[str]], all_tasks: List[str]) -> List[str]:
     """Find maximum subset of tasks that can be executed (handles cycles)."""
     model = cp_model.CpModel()
     n_tasks = len(all_tasks)
@@ -119,7 +120,7 @@ def solve_maximum_subset(dependencies, all_tasks):
     return []
 
 
-def parse_tasks(tasks_text):
+def parse_tasks(tasks_text: str) -> Tuple[List[str], Dict[str, str]]:
     """Parse tasks from text input."""
     if not tasks_text.strip():
         return [], {}
@@ -140,7 +141,7 @@ def parse_tasks(tasks_text):
     return sorted(tasks), original_names
 
 
-def generate_mermaid_gantt(task_order, original_names, durations=None, start_time=None):
+def generate_mermaid_gantt(task_order: List[str], original_names: Dict[str, str], durations: Optional[Dict[str, int]] = None, start_time: Optional[datetime] = None) -> str:
     """Generate Mermaid Gantt chart syntax with minute granularity and selectable start time."""
     if not task_order:
         return "gantt\n    title Task Execution Timeline\n    dateFormat  YYYY-MM-DD HH:mm\n    section No Tasks\n    No tasks to display : 2024-01-01 08:00, 1m"
@@ -177,7 +178,7 @@ def generate_mermaid_gantt(task_order, original_names, durations=None, start_tim
     return gantt
 
 
-def generate_mermaid_flowchart(dependencies, all_tasks, original_names):
+def generate_mermaid_flowchart(dependencies: Dict[str, List[str]], all_tasks: List[str], original_names: Dict[str, str]) -> str:
     """Generate Mermaid flowchart syntax."""
     if not all_tasks:
         return "flowchart TD\n    A[No tasks to display]"
@@ -206,7 +207,7 @@ def generate_mermaid_flowchart(dependencies, all_tasks, original_names):
     return flowchart
 
 
-def update_dropdowns(tasks_text):
+def update_dropdowns(tasks_text: str) -> Tuple[gr.Dropdown, gr.CheckboxGroup]:
     """Update dropdown choices when tasks change."""
     tasks, original_names = parse_tasks(tasks_text)
 
@@ -224,7 +225,7 @@ def update_dropdowns(tasks_text):
     )
 
 
-def add_dependencies(task_display, required_display_list, current_deps):
+def add_dependencies(task_display: str, required_display_list: List[str], current_deps: List[str]) -> Tuple[List[str], str]:
     """Add multiple dependencies for a single task."""
     if not task_display:
         return current_deps, "⚠️ Please select a task"
@@ -281,7 +282,7 @@ def add_dependencies(task_display, required_display_list, current_deps):
     return updated_deps, status
 
 
-def remove_dependency(deps_to_remove, current_deps):
+def remove_dependency(deps_to_remove: List[str], current_deps: List[str]) -> Tuple[List[str], str]:
     """Remove selected dependencies."""
     if not deps_to_remove:
         return current_deps, "⚠️ Please select dependencies to remove"
@@ -291,7 +292,7 @@ def remove_dependency(deps_to_remove, current_deps):
     return updated_deps, f"✅ Removed {removed_count} dependencies"
 
 
-def format_dependencies_display(dependencies_list):
+def format_dependencies_display(dependencies_list: List[str]) -> str:
     """Format dependencies for display."""
     if not dependencies_list:
         return "No dependencies added yet."
@@ -313,8 +314,8 @@ def format_dependencies_display(dependencies_list):
 
 
 def solve_dependencies(
-    tasks_text, dependencies_list, durations_state: dict | None = None
-):
+    tasks_text: str, dependencies_list: List[str], durations_state: Optional[Dict[str, Union[str, int]]] = None
+) -> Tuple[str, str, str, str, str, str, str]:
     """Solve the task ordering problem."""
     tasks, task_original_names = parse_tasks(tasks_text)
 
@@ -603,7 +604,7 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
         """)
 
     # Event handlers
-    def update_ui_after_tasks_change(tasks_text, current_deps):
+    def update_ui_after_tasks_change(tasks_text: str, current_deps: List[str]) -> Tuple[gr.Dropdown, gr.CheckboxGroup, gr.CheckboxGroup]:
         """Update dropdowns and dependency checkboxes when tasks change."""
         tasks, original_names = parse_tasks(tasks_text)
 
@@ -626,7 +627,7 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
             gr.CheckboxGroup(choices=checkbox_choices, value=[]),  # remove_deps
         )
 
-    def handle_add_dependencies(task, required_tasks, current_deps):
+    def handle_add_dependencies(task: str, required_tasks: List[str], current_deps: List[str]) -> Tuple[List[str], str, gr.CheckboxGroup, str, List[str]]:
         """Handle adding dependencies and update UI."""
         updated_deps, status = add_dependencies(task, required_tasks, current_deps)
         display = format_dependencies_display(updated_deps)
@@ -640,7 +641,7 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
             [],  # requirements_checkbox (clear)
         )
 
-    def handle_remove_dependencies(deps_to_remove, current_deps):
+    def handle_remove_dependencies(deps_to_remove: List[str], current_deps: List[str]) -> Tuple[List[str], str, str, gr.CheckboxGroup]:
         """Handle removing dependencies and update UI."""
         updated_deps, status = remove_dependency(deps_to_remove, current_deps)
         display = format_dependencies_display(updated_deps)
@@ -653,7 +654,7 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
             gr.CheckboxGroup(choices=checkbox_choices, value=[]),  # remove_deps
         )
 
-    def clear_all_dependencies():
+    def clear_all_dependencies() -> Tuple[List[str], str, gr.CheckboxGroup]:
         """Clear all dependencies."""
         return (
             [],  # dependencies_state
@@ -662,7 +663,7 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
         )
 
     # Example loaders
-    def load_morning_example():
+    def load_morning_example() -> Tuple[str, List[str], gr.CheckboxGroup]:
         tasks = "Wake_up\nShower\nBrush_teeth\nGet_dressed\nEat_breakfast\nMake_coffee\nLeave_house"
         return (
             tasks,
@@ -670,7 +671,7 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
             gr.CheckboxGroup(choices=[], value=[]),
         )
 
-    def load_cooking_example():
+    def load_cooking_example() -> Tuple[str, List[str], gr.CheckboxGroup]:
         tasks = "Shop_ingredients\nPrep_vegetables\nPreheat_oven\nCook_main_dish\nMake_sauce\nPlate_food\nServe_dinner"
         return (
             tasks,
@@ -678,7 +679,7 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
             gr.CheckboxGroup(choices=[], value=[]),
         )
 
-    def load_project_example():
+    def load_project_example() -> Tuple[str, List[str], gr.CheckboxGroup]:
         tasks = "Research\nPlan\nDesign\nDevelop\nTest\nDeploy\nDocument\nReview"
         return (
             tasks,
@@ -687,7 +688,7 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
         )
 
     # Utility: update durations table to match tasks
-    def update_durations_table(tasks_text, old_duration_rows):
+    def update_durations_table(tasks_text: str, old_duration_rows: List[List[Any]]) -> List[List[str]]:
         tasks, original_names = parse_tasks(tasks_text)
         shown_task_set = set()
         updated_rows = []
@@ -704,10 +705,10 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
         return updated_rows
 
     # Converts Dataframe rows to durations dict (normalized)
-    def table_rows_to_durations(df: pandas.DataFrame):
+    def table_rows_to_durations(df: pandas.DataFrame) -> List[Dict[str, Any]]:
         return df.to_dict(orient="records")
 
-    def update_durations_state(rows):
+    def update_durations_state(rows: pandas.DataFrame) -> List[Dict[str, Any]]:
         return table_rows_to_durations(rows)
 
     # Wire up events

schedule.py

@@ -1,6 +1,6 @@
 from ortools.sat.python import cp_model
 
-def main():
+def main() -> None:
     model = cp_model.CpModel()
     horizon = 48  # 24-hour day in 30-minute slots (adjust as needed)
 

test_app.py

@@ -2,7 +2,7 @@ from app import parse_requirements, parse_tasks, solve_all_tasks, generate_merma
 from datetime import datetime
 
 
-def test_parse_requirements_with_spaces():
+def test_parse_requirements_with_spaces() -> None:
     reqs = [
         "take out trash requires bag",
         "Dinner requires Shopping",
@@ -23,7 +23,7 @@ def test_parse_requirements_with_spaces():
     assert original_names["take out trash"] == "take out trash"
 
 
-def test_parse_tasks_and_original_names():
+def test_parse_tasks_and_original_names() -> None:
     txt = "Wash dishes\nTake out trash, Make sandwich "
     tasks, originals = parse_tasks(txt)
     assert set(tasks) == {"wash dishes", "take out trash", "make sandwich"}
@@ -32,14 +32,14 @@ def test_parse_tasks_and_original_names():
     assert originals["wash dishes"] == "Wash dishes"
 
 
-def test_solve_all_tasks_simple():
+def test_solve_all_tasks_simple() -> None:
     reqs = ["a requires b", "b requires c"]
     dependencies, all_tasks, _ = parse_requirements(reqs)
     result = solve_all_tasks(dependencies, all_tasks)
     assert result == ["c", "b", "a"]
 
 
-def test_solve_all_tasks_with_spaces():
+def test_solve_all_tasks_with_spaces() -> None:
     reqs = ["Do homework requires eat dinner", "eat dinner requires cook"]
     dependencies, all_tasks, _ = parse_requirements(reqs)
     result = solve_all_tasks(dependencies, all_tasks)
@@ -54,7 +54,7 @@ def test_solve_all_tasks_with_spaces():
 #     assert result == ["d"]
 
 
-def test_generate_mermaid_gantt_minutes():
+def test_generate_mermaid_gantt_minutes() -> None:
     order = ["a", "b", "c"]
     names = {"a": "Alpha", "b": "Beta", "c": "Gamma"}
     durations = {"a": 15, "b": 30, "c": 45}