class Calculator:
    """
    Calculator App class
    """

    def __init__(self, *args: Any, **kwds: Any) -> None:
        pass

    def __str__(self, *args: Any, **kwds: Any) -> Any:
        pass

    def __del__(self, *args: Any, **kwds: Any) -> Any:
        pass

    def __call__(self, *args: Any, **kwds: Any) -> Any:
        pass

    @staticmethod
    def suma(a: float = 1, b: float = 1) -> float:
        """Function that returns addition of two integer numbers

        Args:
            a (float, optional): first number to add. Defaults to 1.
            b (float, optional): second number to add. Defaults to 1.

        Returns:
            float: addition of a and b
        """
        if isinstance(a, str) or isinstance(b, str):
            raise AdditionError("Invalid input. Only numbers are allowed")

        return a + b

    @staticmethod
    def resta(a: float = 1, b: float = 1) -> float:
        """Function that returns difference of two integer numbers

        Args:
            a (float, optional): _description_. Defaults to 1.
            b (float, optional): _description_. Defaults to 1.

        Returns:
            float: difference of a and b
        """
        if isinstance(a, str) or isinstance(b, str):
            raise SubstractionError("Invalid input. Only numbers are allowed")

        return a - b

    @staticmethod
    def multiplicacion(a: float = 1, b: float = 1) -> float:
        """Function that multiplies two float values

        Args:
            a (float, optional): First parameter. Defaults to 1.
            b (float, optional): Second parameter. Defaults to 1.

        Returns:
            float: multiplication of a and b params
        """
        if isinstance(a, str) or isinstance(b, str):
            error_msg = "Invalid input. Only numbers are allowed"
            raise MultiplicationError(error_msg)

        return a * b

    @staticmethod
    def division(a: float = 1, b: float = 1) -> float | ZeroDivisionError:
        """Function that returns division of two values where
           b is non zero

        Args:
            a (float, optional): First param. Defaults to 1.
            b (float, optional): Second param (non-zero). Defaults to 1.

        Returns:
            float: division result of a / b where b is non-zero
        """
        if isinstance(a, str) or isinstance(b, str):
            raise DivisionError("Invalid input. Only numbers are allowed")

        try:
            return a / b
        except ZeroDivisionError as error:
            msg = "Division by 0 not allowed!"
            raise ZeroDivisionError(msg) from error

class Executor:
    """
    Executor class to manage worker processes.
    """

    def __init__(self, num_workers: int = 4) -> None:
        self.tasks_queue: Queue = Queue()
        self.workers = [
            Process(target=self.worker) for _ in range(num_workers)
        ]  # noqa: E501
        for worker in self.workers:
            worker.start()

    def add_task(self, task: Callable | None, *args: Sequence[Any]) -> None:
        """
        Add a task to the queue. Task should be a callable with its arguments.
        """
        self.tasks_queue.put((task, args))

    def worker(self) -> None:
        """
        Worker process: Retrieve tasks from the queue and execute them.
        """
        while True:
            task, args = self.tasks_queue.get()
            if task is None:
                # None is the signal to stop.
                break
            task(*args)

    def stop_workers(self) -> None:
        """
        Stop all worker processes.
        """
        for _ in self.workers:
            self.add_task(None)  # Signal to stop.
        for worker in self.workers:
            worker.join()

    def execute(self, task: Callable, *args: Sequence[Any]) -> None:
        """
        Execute method to add tasks. Now accepts a task and its arguments.
        """
        # Add tasks
        for arg in args:
            self.add_task(task, arg)