def interrupt(self, inter: Optional[Interrupt] = None) -> None:
        """
        Interrupts a process that has been previously :py:meth:`pause`d or made to :py:meth:`advance`, by resuming it
        immediately and raising an :py:class:`Interrupt` exception on it. This exception can be captured by the
        interrupted process and leveraged for various purposes, such as timing out on a wait or generating activity
        prompting immediate reaction.

        :param inter:
            Exception to raise on the :py:class:`Process`; if ``None`` is given, an instance of :py:class:`Interrupt` is
            raised. This allows one to use specialized :py:class:`Interrupt` subclasses to as to implement
            non-interfering mixed interruption stacks.  For instance, a process may advance towards a certain timeout as
            it waits for multiple resources concurrently. Should it hit the timeout, it would :py:meth:`interrupt` the
            waiting processes so as to clean up after itself. If these processes have themselves a timeout mechanism of
            their own, also based on interrupts, using a subclass can help them distinguish between these and the
            clean-up interrupts.
        """
        if inter is None:
            inter = Interrupt()
        if _logger is not None:
            _log(INFO, "Process", self.local.name, "interrupt", type=type(inter).__name__)
        self.rsim()._schedule(0.0, self.throw, inter)
Interrupts a process that has been previously :py:meth:`pause`d or made to :py:meth:`advance`, by resuming it
        immediately and raising an :py:class:`Interrupt` exception on it. This exception can be captured by the
        interrupted process and leveraged for various purposes, such as timing out on a wait or generating activity
        prompting immediate reaction.

        :param inter:
            Exception to raise on the :py:class:`Process`; if ``None`` is given, an instance of :py:class:`Interrupt` is
            raised. This allows one to use specialized :py:class:`Interrupt` subclasses to as to implement
            non-interfering mixed interruption stacks.  For instance, a process may advance towards a certain timeout as
            it waits for multiple resources concurrently. Should it hit the timeout, it would :py:meth:`interrupt` the
            waiting processes so as to clean up after itself. If these processes have themselves a timeout mechanism of
            their own, also based on interrupts, using a subclass can help them distinguish between these and the
            clean-up interrupts.