code: def interrupt(self, inter: Optional[Interrupt] = None) -> None:
          
          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)
docs: 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.