با استفاده از یک الگوریتم نمودار acyclic کارگردانی برای پیش بینی بهره وری

tasks = [
    { 
        "id": 1, 
        "name": "Design UI", 
        "days_length": 3, 
        "dependencies": [] 
    },
    { 
        "id": 2, 
        "name": "Implement UI", 
        "days_length": 7, 
        "dependencies": [1] 
    },
    { 
        "id": 3, 
        "name": "Testing", 
        "days_length": 2, 
        "dependencies": [2] 
    },
    { 
        "id": 4, 
        "name": "Project Documentation", 
        "days_length": 4, 
        "dependencies": [] 
    }
]

from collections import defaultdict, deque
from datetime import datetime, timedelta, time

def topological_sort(self, tasks):
    # Step 1: Calculate in-degrees and construct the adjacency list
    in_degree = defaultdict(int)
    adjacency_list = defaultdict(list) 
    for task in tasks.values():
        # Initialize in-degree for the current task
        in_degree[task.id] = in_degree.get(task.id, 0)
        for dependency in task.dependencies:
            adjacency_list[dependency.id].append(task)
            in_degree[task.id] += 1

    # Step 2: Collect all tasks with in-degree 0 (tasks with no dependencies) for initial adding
    zero_in_degree = deque([task for task in tasks.values() if in_degree[task.id] == 0])

    # Step 3: Process tasks with in-degree 0
    top_order = []
    while zero_in_degree:
        # 3.1: add tasks that have no dependencies
        current_task = zero_in_degree.popleft()
        top_order.append(current_task)

        # Reduce the in-degree of dependent tasks
        # 3.2: process dependent tasks 
        # get list of tasks that point to this task
        for dependent_task in adjacency_list[current_task.id]:
            # subtract -1 to account for the parent task that points to this
            in_degree[dependent_task.id] -= 1  # Step 1: Reduce the in-degree of each dependent task

            # this dependent task has no other dependencies
            if in_degree[dependent_task.id] == 0: # Step 2: Check if this dependent task now has no incoming edges (all depedendencies are resolved)
                zero_in_degree.append(tasks[dependent_task.id]) # Step 3: Add it to the processing queue (tasks with no incoming edges)

    return top_order