Python Priority Scheduling (Non-Preemptive) Algorithm with Same Arrival Time

Python Priority Scheduling (Non-Preemptive) Algorithm with Same Arrival Time

The task is to find the Average Waiting Time and Average Turnaround Time of the given processes with their Burst Time using Priority Scheduling Algorithm.
Priority is a scheduling policy that selects the waiting process with the highest priority to execute next.
Priority Scheduling is a Non Pre-emptive and Pre-emptive Algorithm, hence the process which has the Highest Priority is selected first.
Here we are considering Non Pre-emptive version of Priority Scheduling, hence the process which has the Highest Priority will be served first and the next process will be served only after the previous process is executed completely.
Here we are considering the arrival time of all processes to be 0.
Start Time: Time at which the execution of the process starts
Completion Time: Time at which the process completes its execution
Turnaround Time: Completion Time - Arrival Time
Waiting Time: Turnaround Time - Burst Time

class Priority:

    def processData(self, no_of_processes):
        process_data = []
        for i in range(no_of_processes):
            temporary = []
            process_id = int(input("Enter Process ID: "))

            burst_time = int(input(f"Enter Burst Time for Process {process_id}: "))

            priority = int(input(f"Enter Priority for Process {process_id}: "))

            temporary.extend([process_id, 0, burst_time, priority])
            '0' is the arrival time of the processes
        Priority.schedulingProcess(self, process_data)

    def schedulingProcess(self, process_data):
        process_data.sort(key=lambda x: x[3], reverse=True)
        Sort according to Priority considering Higher the Value, Higher the Priority
        start_time = []
        exit_time = []
        s_time = 0
        for i in range(len(process_data)):
            s_time = s_time + process_data[i][2]
            e_time = s_time
        t_time = Priority.calculateTurnaroundTime(self, process_data)
        w_time = Priority.calculateWaitingTime(self, process_data)
        Priority.printData(self, process_data, t_time, w_time)

    def calculateTurnaroundTime(self, process_data):
        total_turnaround_time = 0
        for i in range(len(process_data)):
            turnaround_time = process_data[i][4] - process_data[i][1]
            turnaround_time = completion_time - arrival_time
            total_turnaround_time = total_turnaround_time + turnaround_time
        average_turnaround_time = total_turnaround_time / len(process_data)
        average_turnaround_time = total_turnaround_time / no_of_processes
        return average_turnaround_time

    def calculateWaitingTime(self, process_data):
        total_waiting_time = 0
        for i in range(len(process_data)):
            waiting_time = process_data[i][5] - process_data[i][2]
            waiting_time = turnaround_time - burst_time
            total_waiting_time = total_waiting_time + waiting_time
        average_waiting_time = total_waiting_time / len(process_data)
        average_waiting_time = total_waiting_time / no_of_processes
        return average_waiting_time

    def printData(self, process_data, average_turnaround_time, average_waiting_time):
        process_data.sort(key=lambda x: x[0])
        Sort according to the Process ID
        print("Process_ID  Arrival_Time  Burst_Time       Priority  Completion_Time  Turnaround_Time  Waiting_Time")

        for i in range(len(process_data)):
            for j in range(len(process_data[i])):
                print(process_data[i][j], end="\t\t\t\t")

        print(f'Average Turnaround Time: {average_turnaround_time}')

        print(f'Average Waiting Time: {average_waiting_time}')

if __name__ == "__main__":
    no_of_processes = int(input("Enter number of processes: "))
    priority = Priority()