code: def run(self):
          
          if self.running or self.finished:
              return
          try:
              self.running = True
              while True:
                  future = self.future
                  if not future.done():
                      return
                  self.future = None
                  try:
                      orig_stack_contexts = stack_context._state.contexts
                      exc_info = None
  
                      try:
                          value = future.result()
                      except Exception:
                          self.had_exception = True
                          exc_info = sys.exc_info()
                      future = None
  
                      if exc_info is not None:
                          try:
                              yielded = self.gen.throw(*exc_info)
                          finally:
                              # Break up a reference to itself
                              # for faster GC on CPython.
                              exc_info = None
                      else:
                          yielded = self.gen.send(value)
  
                      if stack_context._state.contexts is not orig_stack_contexts:
                          self.gen.throw(
                              stack_context.StackContextInconsistentError(
                                  'stack_context inconsistency (probably caused '
                                  'by yield within a "with StackContext" block)'))
                  except (StopIteration, Return) as e:
                      self.finished = True
                      self.future = _null_future
                      if self.pending_callbacks and not self.had_exception:
                          # If we ran cleanly without waiting on all callbacks
                          # raise an error (really more of a warning).  If we
                          # had an exception then some callbacks may have been
                          # orphaned, so skip the check in that case.
                          raise LeakedCallbackError(
                              "finished without waiting for callbacks %r" %
                              self.pending_callbacks)
                      self.result_future.set_result(_value_from_stopiteration(e))
                      self.result_future = None
                      self._deactivate_stack_context()
                      return
                  except Exception:
                      self.finished = True
                      self.future = _null_future
                      self.result_future.set_exc_info(sys.exc_info())
                      self.result_future = None
                      self._deactivate_stack_context()
                      return
                  if not self.handle_yield(yielded):
                      return
                  yielded = None
          finally:
              self.running = False
docs: Starts or resumes the generator, running until it reaches a
          yield point that is not ready.