code: def stop(self):
          
          if self._died.ready():
              _log.debug('already stopped %s', self)
              return
  
          if self._being_killed:
              # this race condition can happen when a container is hosted by a
              # runner and yields during its kill method; if it's unlucky in
              # scheduling the runner will try to stop() it before self._died
              # has a result
              _log.debug('already being killed %s', self)
              try:
                  self._died.wait()
              except:
                  pass  # don't re-raise if we died with an exception
              return
  
          _log.debug('stopping %s', self)
  
          with _log_time('stopped %s', self):
  
              # entrypoint have to be stopped before dependencies to ensure
              # that running workers can successfully complete
              self.entrypoints.all.stop()
  
              # there might still be some running workers, which we have to
              # wait for to complete before we can stop dependencies
              self._worker_pool.waitall()
  
              # it should be safe now to stop any dependency as there is no
              # active worker which could be using it
              self.dependencies.all.stop()
  
              # finally, stop remaining extensions
              self.subextensions.all.stop()
  
              # any any managed threads they spawned
              self._kill_managed_threads()
  
              self.started = False
  
              # if `kill` is called after `stop`, they race to send this
              if not self._died.ready():
                  self._died.send(None)
docs: Stop the container gracefully.
  
          First all entrypoints are asked to ``stop()``.
          This ensures that no new worker threads are started.
  
          It is the extensions' responsibility to gracefully shut down when
          ``stop()`` is called on them and only return when they have stopped.
  
          After all entrypoints have stopped the container waits for any
          active workers to complete.
  
          After all active workers have stopped the container stops all
          dependency providers.
  
          At this point there should be no more managed threads. In case there
          are any managed threads, they are killed by the container.