docs: def wait( self, timeout = -1 ):
          """Wait for all pending results to be finished. If timeout is set,
          return after this many seconds regardless.
  
          :param timeout: timeout period in seconds (defaults to forever)
          :returns: True if all the results completed"""
  
          # we can't use ipyparallel.Client.wait() for this, because that
          # method only works for cases where the Client object is the one that
          # submitted the jobs to the cluster hub -- and therefore has the
          # necessary data structures to perform synchronisation. This isn't the
          # case for us, as one of the main goals of epyc is to support disconnected
          # operation, which implies a different Client object retrieving results
          # than the one that submitted the jobs in the first place. This is
          # unfortunate, but understandable given the typical use cases for
          # Client objects.
          #
          # Instead. we have to code around a little busily. The ClusterLab.WaitingTime
          # global sets the latency for waiting, and we repeatedly wait for this amount
          # of time before updating the results. The latency value essentially controls
          # how busy this process is: given that most simulations are expected to
          # be long, a latency in the tens of seconds feels about right as a default
          if self.numberOfPendingResults() > 0:
              # we've got pending results, wait for them
              timeWaited = 0
              while (timeout < 0) or (timeWaited < timeout):
                  if self.numberOfPendingResults() == 0:
                      # no pending jobs left, we're complete
                      return True
                  else:
                      # not done yet, calculate the waiting period
                      if timeout == -1:
                          # wait for the default waiting period
                          dt = self.WaitingTime
                      else:
                          # wait for the default waiting period or until the end of the timeout.
                          # whichever comes first
                          if (timeout - timeWaited) < self.WaitingTime:
                              dt = timeout - timeWaited
                          else:
                              dt = self.WaitingTime
                              
                      # sleep for a while
                      time.sleep(dt)
                      timeWaited = timeWaited + dt
  
              # if we get here, the timeout expired, so do a final check
              # and then exit
              return (self.numberOfPendingResults() == 0)
  
          else:
              # no results, so we got them all
              return True