code: def _schedule(self, delay: float, event: Callable, *args: Any, **kwargs: Any) -> int:
          
          if _logger is not None:
              self._log(
                  DEBUG,
                  "schedule",
                  delay=delay,
                  fn=event,
                  args=args,
                  kwargs=kwargs,
                  counter=self._counter,
                  __now=self.now()
              )
          delay = float(delay)
          if delay < 0.0:
              raise ValueError("Delay must be positive.")
  
          # Use counter to strictly order events happening at the same simulated time. This gives a total order on events,
          # working around the heap queue not yielding a stable ordering.
          id_event = self._counter
          heappush(self._events, _Event(self._ts_now + delay, id_event, event, *args, **kwargs))
          self._counter += 1
          return id_event
docs: Schedules a one-time event to be run along the simulation.  The event is scheduled relative to current simulator
          time, so delay is expected to be a positive simulation time interval. The `event' parameter corresponds to a
          callable object (e.g. a function): it will be called so as to "execute" the event, with the positional and
          keyword parameters that follow `event` in the call to `_schedule()` (note that the value of these arguments are
          evaluated when `_schedule()` is called, not when the event is executed). Once this event function returns, the
          simulation carries on to the next event, or stops if none remain.
  
          Remark that this method is private, and is meant for internal usage by the :py:class:`Simulator` and
          :py:class:`Process` classes, and helper functions of this module.
  
          :return: Unique identifier for the scheduled event.