code: def wait_pid(
      pid,
      timeout=None,
      proc_name=None,
      _waitpid=os.waitpid,
      _timer=getattr(time, "monotonic", time.time),
      _min=min,
      _sleep=time.sleep,
      _pid_exists=pid_exists,
  ):
      """Wait for a process PID to terminate.
  
      If the process terminated normally by calling exit(3) or _exit(2),
      or by returning from main(), the return value is the positive integer
      passed to *exit().
  
      If it was terminated by a signal it returns the negated value of the
      signal which caused the termination (e.g. -SIGTERM).
  
      If PID is not a children of os.getpid() (current process) just
      wait until the process disappears and return None.
  
      If PID does not exist at all return None immediately.
  
      If *timeout* != None and process is still alive raise TimeoutExpired.
      timeout=0 is also possible (either return immediately or raise).
      """
      if pid <= 0:
          raise ValueError("can't wait for PID 0")  # see "man waitpid"
      interval = 0.0001
      flags = 0
      if timeout is not None:
          flags |= os.WNOHANG
          stop_at = _timer() + timeout
  
      def sleep(interval):
          # Sleep for some time and return a new increased interval.
          if timeout is not None:
              if _timer() >= stop_at:
                  raise TimeoutExpired(timeout, pid=pid, name=proc_name)
          _sleep(interval)
          return _min(interval * 2, 0.04)
  
      # See: https://linux.die.net/man/2/waitpid
      while True:
          try:
              retpid, status = os.waitpid(pid, flags)
          except InterruptedError:
              interval = sleep(interval)
          except ChildProcessError:
              # This has two meanings:
              # - PID is not a child of os.getpid() in which case
              #   we keep polling until it's gone
              # - PID never existed in the first place
              # In both cases we'll eventually return None as we
              # can't determine its exit status code.
              while _pid_exists(pid):
                  interval = sleep(interval)
              return
          else:
              if retpid == 0:
                  # WNOHANG flag was used and PID is still running.
                  interval = sleep(interval)
                  continue
              elif os.WIFEXITED(status):
                  # Process terminated normally by calling exit(3) or _exit(2),
                  # or by returning from main(). The return value is the
                  # positive integer passed to *exit().
                  return os.WEXITSTATUS(status)
              elif os.WIFSIGNALED(status):
                  # Process exited due to a signal. Return the negative value
                  # of that signal.
                  return negsig_to_enum(-os.WTERMSIG(status))
              # elif os.WIFSTOPPED(status):
              #     # Process was stopped via SIGSTOP or is being traced, and
              #     # waitpid() was called with WUNTRACED flag. PID is still
              #     # alive. From now on waitpid() will keep returning (0, 0)
              #     # until the process state doesn't change.
              #     # It may make sense to catch/enable this since stopped PIDs
              #     # ignore SIGTERM.
              #     interval = sleep(interval)
              #     continue
              # elif os.WIFCONTINUED(status):
              #     # Process was resumed via SIGCONT and waitpid() was called
              #     # with WCONTINUED flag.
              #     interval = sleep(interval)
              #     continue
              else:
                  # Should never happen.
                  raise ValueError(
                      "unknown process exit status %r" % status
                  )
  
file_path: catboost/contrib/python/psutil/py3/psutil/_psposix.py
imports: import glob
  import os
  import signal
  import sys
  import time
  from ._common import memoize
  from ._common import sdiskusage
  from ._common import TimeoutExpired
  from ._common import usage_percent
  from ._compat import ChildProcessError
  from ._compat import FileNotFoundError
  from ._compat import InterruptedError
  from ._compat import PermissionError
  from ._compat import ProcessLookupError
  from ._compat import PY3
  from ._compat import unicode
label_desc: Use image node_id 2 for calling a global function with example usage: wait_pid(pid, timeout, proc_name, _waitpid, _timer, _min, _sleep, _pid_exists) and returns: _min, os, negsig_to_enum