Bug Report: IPC is SLOW about salve HOT 5 CLOSED

from multiprocessing import Process, Pipe, Queue
from multiprocessing.connection import Connection
from time import sleep, time
from typing import Any, NotRequired, TypedDict
from random import randint
from sys import exit


class Message(TypedDict):
    """Base class for messages in and out of the server"""

    id: int


class Request(Message):
    """Request results/output from the server"""

    index: int


class Response(Message):
    """Server responses to requests, notifications, and pings"""

    cancelled: bool
    result: NotRequired[str]


class Client:
    def __init__(self) -> None:
        self.used_ids: list[int] = []
        self.current_id: int = 0
        self.client_end: Connection
        self.response_queue: Queue[Response] = Queue()
        self.requests_queue: Queue[Request] = Queue()
        self.create_server()

    def create_server(self) -> None:
        self.client_end, server_end = Pipe()
        self.proccess = Process(
            target=Server,
            args=(server_end, self.response_queue, self.requests_queue),
        )
        self.proccess.start()
        self.response_queue.get()  # Wait until server has been made

    def check_server(self) -> None:
        if not self.proccess.is_alive():
            self.create_server()

    def make_request(self, request: int) -> None:
        self.check_server()
        id = randint(0, 5000)
        while id in self.used_ids:
            id = randint(0, 5000)

        self.used_ids.append(id)
        self.current_id = id
        final_request: Request = {"id": id, "index": request}
        self.requests_queue.put(final_request)

    def check_output(self) -> Any:
        items: list[Response] = []
        while not self.response_queue.empty():
            items.append(self.response_queue.get())

        wanted_response: Response = {"id": 0, "cancelled": True}
        for item in items:
            id: int = item["id"]
            self.used_ids.remove(id)
            if id == self.current_id:
                wanted_response = item
        return wanted_response

    def kill_server(self) -> None:
        self.proccess.kill()


class Server:
    def __init__(
        self,
        server_end: Connection,
        response_queue: Queue,
        requests_queue: Queue,
    ) -> None:
        self.internal_list: list[str] = ["Yuh", "anyways", "soooo"]
        self.server_end: Connection = server_end
        self.response_queue: Queue[Response] = response_queue
        self.requests_queue: Queue[Request] = requests_queue
        self.response_queue.put({"id": 0, "cancelled": False, "result": ""})
        self.old_time = time()

        while True:
            self.run_tasks()

    def run_tasks(self) -> None:
        current_time = time()
        if current_time - self.old_time > 5:
            exit(0)

        while not self.requests_queue.empty():
            self.old_time = current_time
            request: Request = self.requests_queue.get()
            cancelled: bool = not self.response_queue.empty()
            output = ""
            if not cancelled:
                try:
                    output = self.internal_list[request["index"]]
                except IndexError:
                    output = "Bad Index"
            final_response: Response = {
                "id": request["id"],
                "cancelled": cancelled,
                "result": output,
            }
            self.response_queue.put(final_response)

        sleep(0.0025)


if __name__ == "__main__":
    st = time()
    c = Client()
    c.make_request(3)
    while (x := c.check_output()) is None or x == {"id": 0, "cancelled": True}:
        continue
    print(x)
    c.kill_server()
    print(time() - st, c.__sizeof__())