Помощь Python. Возникают ошибки при запуске

Не могу понять как исправить ошибки.

#!/usr/bin/env python3
# -*- config: utf-8 -*-

from tkinter import *
import queue
import threading
import time


class QueueThread(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    def run(self) -> None:
        print(f'Старт потока {self.name}')
        process_queue()
        print(f'Завершение потока {self.name}')


def process_queue():
    while True:
        try:
            x = ps_queue.get(block=False)
            process1 = idx[x]
            y = ps_queue.get(block=False)
            process2 = idx2[y]
            z = ps_queue.get(block=False)
            process3 = idx3[z]
            t1 = ps_queue.get(block=False)
            process4 = idx4[t1]
            t2 = ps_queue.get(block=False)
            process5 = idx5[t2]
            t3 = ps_queue.get(block=False)
            process6 = idx6[t3]
        except queue.Empty:
            return
        else:
            print_factors(x, y, z, t1, t2, t3, process1, process2, process3, process4, process5, process6, res_list)

        time.sleep(1)


def print_factors(x, y, z, t1, t2, t3, process1, process2, process3, process4, process5, process6, res_list):
    try:
        for g in results:
            res_list = g[x]
    except KeyError:
        res_list = []
    current_res = []
    st = time.time()
    try:
        begin = drop_list[x]
    except KeyError:
        begin = 1
    for i in range(begin, x + 1):
        current = time.time()
        if i == x:
            del idx[x]

        elif y == 24:
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 1:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 2:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 4:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 1:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 2:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 16:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(t2)
            term.insert(END, f'Процесс PID:2 завершил работу, и перешел в состояние STATE - 8:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 1:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 2:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 4:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 16:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(t1)
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 8:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 16:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(t3)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 8:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            break
        elif x == 24:
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 1:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 2:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 16:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(t1)
            term.insert(END, f'Процесс PID:1 завершил работу, и перешел в состояние STATE - 8:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 1:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 2:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 16:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(t2)
            term.insert(END, f'Процесс PID:2 завершил работу, и перешел в состояние STATE - 8:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 1:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 2:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 16:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(t3)
            term.insert(END, f'Процесс PID:3 завершил работу, и перешел в состояние STATE - 8:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            break
        elif z == 24:
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 1:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 2:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 4:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 1:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 2:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 16:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(t3)
            term.insert(END, f'Процесс PID:3 завершил работу, и перешел в состояние STATE - 8:\n'
                             f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
                             f'Время выполнения процесса - {t3}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 16:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(t1)
            term.insert(END, f'Процесс PID:1 завершил работу, и перешел в состояние STATE - 8:\n'
                             f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
                             f'Время выполнения процесса - {t1}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 1:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 2:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 16:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(t2)
            term.insert(END, f'Процесс PID:2 завершил работу, и перешел в состояние STATE - 8:\n'
                             f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
                             f'Время выполнения процесса - {t2}с \n \n'
                             f'----------------------------------------------------------------\n \n')
            time.sleep(1.5)
            break


def entry_get(event):
    global idx, cm_list, ps_queue
    command = en1.get()
    term.insert(END, f'# {command} \n')
    cm_list.append(command)
    en1.delete(0, 'end')
    if command == 'exit':
        root.destroy()
    elif command.startswith('add1 '):
        parts = command.split(' ', maxsplit=3)
        num = int(parts[1])
        proc = float(0.5)
        idx[num] = proc
        ps_queue.put(num)
    elif command.startswith('add2 '):
        parts = command.split(' ', maxsplit=3)
        num = int(parts[1])
        proc = float(0.5)
        idx2[num] = proc
        ps_queue.put(num)
    elif command.startswith('add3 '):
        parts = command.split(' ', maxsplit=3)
        num = int(parts[1])
        proc = float(0.5)
        idx3[num] = proc
        ps_queue.put(num)
    elif command.startswith('addt1 '):
        parts = command.split(' ', maxsplit=3)
        num = int(parts[1])
        proc = float(0.5)
        idx4[num] = proc
        ps_queue.put(num)
    elif command.startswith('addt2 '):
        parts = command.split(' ', maxsplit=3)
        num = int(parts[1])
        proc = float(0.5)
        idx5[num] = proc
        ps_queue.put(num)
    elif command.startswith('addt3 '):
        parts = command.split(' ', maxsplit=3)
        num = int(parts[1])
        proc = float(0.5)
        idx6[num] = proc
        ps_queue.put(num)
    elif command == 'clear':
        term.delete(0.0, END)
    elif command == 'start':
        thread1 = QueueThread('A')
        thread1.start()
    elif command == 'list':
        term.insert(END, f'Список приоритетов, состовляющих алгоритм планирования \n')
        for i in idx:
            term.insert(END, f'{i} \n')
        for i in idx2:
            term.insert(END, f'{i} \n')
        for i in idx3:
            term.insert(END, f'{i} \n')
    elif command == 'help':
        term.insert(END, f'"add1 PRIOR" - добавляет уровень приоритета PID1. \n')
        term.insert(END, f'"add2 PRIOR" - добавляет уровень приоритета PID2. \n')
        term.insert(END, f'"add3 PRIOR" - добавляет уровень приоритета PID3. \n')
        term.insert(END, f'"addt1 TIME" - добавляет время выполнения процесса PID1. \n')
        term.insert(END, f'"addt2 TIME" - добавляет время выполнения процесса PID2. \n')
        term.insert(END, f'"addt3 TIME" - добавляет время выполнения процесса PID3. \n')
        term.insert(END, f'"list" - выводит список приоритетов, для алгоритма планирования. \n')
        term.insert(END, f'"clear" - очищает терминал. \n')
        term.insert(END, f'"help" - выводит список команд. \n')
        term.insert(END, f'"start" - запускает алгоритм планирования. \n')
        term.insert(END, f'"exit" - выход. \n')
    else:
        term.insert(END, f'{command} -- неизвестная комманда, используйте "help". \n')


if __name__ == '__main__':
    idx = {}
    idx2 = {}
    idx3 = {}
    idx4 = {}
    idx5 = {}
    idx6 = {}
    res_list = []
    results = []
    drop_list = {}
    cm_list = []
    ps_queue = queue.Queue()
    for x in idx:
        ps_queue.put(x)
    for y in idx2:
        ps_queue.put(y)
    for z in idx3:
        ps_queue.put(z)
    for t1 in idx4:
        ps_queue.put(t1)
    for t2 in idx5:
        ps_queue.put(t2)
    for t3 in idx6:
        ps_queue.put(t3)

    class_grades = {24: "Real time class",
                    13: "High class",
                    10: "Above normal class",
                    8: "Normal class",
                    6: "Below normal class",
                    4: "Idle class"}

    root = Tk()

    root.geometry('570x400')
    root.title("Подсистема управления процессами с алгоритмом планирования на основе абсолютных приоритетов")
    root.resizable(False, False)

    lb1 = Label(text='Командная строка:', width=0)
    lb2 = Label(width=0)
    en1 = Entry(width=65, bg='#333333', fg='white')
    term = Text(bg='#333333', width=65, height=19, fg='white')

    en1.bind('<Return>', entry_get)

    lb1.grid(row=0, column=0, sticky=W, pady=10, padx=5)
    lb2.grid(row=1, column=1, sticky=W)
    en1.grid(row=0, column=1, sticky=W)
    term.grid(row=2, column=0, columnspan=2, padx=20, pady=10)

    root.mainloop()