Homevork 3 ex (Queue OOP python lib)

queue.py

import sys


class Queue:
    def __init__(self, size=0):
        self.queueObject = []
        self.symbols = []
        self.count = {}
        self.opposites = {}
        self.boofer = []
        self.opposites = {"(": ")", "[": "]", "{": "}"}
        self.posites = {")": "(", "]": "[", "}": "{"}

    # Добавить элемент в очередь : a = Queue() a+3 a+4 a+8 *a = [3, 4, 8]*
    def __add__(self, add):
            self.queueObject.append(add)

    # Убрать из очереди n колличество первых элементов a-1 *a=[4, 8]*, a-2 *a=[8]*
    def __sub__(self, sub=1):
        try:
            for i in range(sub):
                self.queueObject.pop(0)
        except IndexError:
            pass

    # Приравнять очередь к чему-либо (массив)
    def __eq__(self,array):
        self.queueString = array

    def __len__(self):
        return len(self.queueObject)

    def throw_boofer(self):
        self.boofer = self.queueObject
        self.clear()

    def get_boofer(self):
        return self.boofer

    # Вывести очередь
    def get_queue(self):
        return self.queueObject

    def clear(self):
        self.queueObject = []

    # Найти первый символ
    def get_front(self):
        try:
            return self.queueObject[0]
        except IndexError:
            return None

    def search(self, symbol):
        for i in self.queueObject:
            if i == symbol:
                return i
        return False

    def search_and_delete(self, symbol):
        self.queueObject.pop(self.search(symbol))

    # разбить строку на символы и добавить ее в буфер
    def split_string_into_boofer(self):
        self.boofer = [i for i in self.queueString]
        self.boofer.pop()
        self.queueString = []

    def get__boofer(self):
        return self.boofer

    def find_symbols(self):
        symbols = list(set(self.queueObject))
        self.symbols = symbols
        return symbols

    # Найти пару (символ : сколько встретился)
    def get_count(self):
        counter_array = []
        for i in self.symbols:
            counter = len([j for j in self.queueObject if j == i])
            counter_array.append(counter)
        self.count = {self.symbols[i]: counter_array[i] for i in range(len(self.symbols))}
        return self.count

    # Вернуть значение из opposites
    def get_opposite_of(self, key):
        if key in self.opposites.keys():
            return self.opposites.get(key)
        elif key in self.posites.keys():
            return self.posites.get(key)

    def delete_all_opposites(self):
        try:
            for i in self.count.keys():
                if i in self.opposites.keys():
                    a = self.count.get(i)
                    b = self.count.get(self.get_opposite_of(i))
                    if not a-b == 0:
                        return False
            return True
        except TypeError:
            return False

    def clear_boofer(self):
        self.boofer = []

    def search_and_delete_last(self, symbol):
        if self.queueObject[len(self.queueObject) - 1] == symbol:
            self.queueObject.pop()

    # Название говорит за себя
    def parse_boofer_exclude__fron_end__mode(self):

        self.clear()
        try:
            for i in self.boofer:
                if i in self.opposites.keys():
                    self.queueObject.append(i)
                else:
                    self.search_and_delete_last(self.get_opposite_of(i))
            if self.queueObject:
                return False
            return True
        except IndexError:
            return False
        finally:
            self.clear_boofer()


def main():
    a = Queue()
    for line in sys.stdin:
        a == line
        a.split_string_into_boofer()
        if a.parse_boofer_exclude__fron_end__mode():
            print("yes")
        else:
            print("no")
        return 0
if __name__ == "__main__":
    main()