up

server/.venv/lib/python3.11/site-packages/setuptools/_distutils/spawn.py

@@ -2,63 +2,20 @@
 
 Provides the 'spawn()' function, a front-end to various platform-
 specific functions for launching another program in a sub-process.
+Also provides the 'find_executable()' to search the path for a given
+executable name.
 """
 
-from __future__ import annotations
-
-import os
-import platform
-import shutil
-import subprocess
 import sys
-import warnings
-from collections.abc import Mapping, MutableSequence
-from typing import TYPE_CHECKING, TypeVar, overload
+import os
+import subprocess
 
-from ._log import log
-from .debug import DEBUG
-from .errors import DistutilsExecError
-
-if TYPE_CHECKING:
-    from subprocess import _ENV
+from distutils.errors import DistutilsExecError
+from distutils.debug import DEBUG
+from distutils import log
 
 
-_MappingT = TypeVar("_MappingT", bound=Mapping)
-
-
-def _debug(cmd):
-    """
-    Render a subprocess command differently depending on DEBUG.
-    """
-    return cmd if DEBUG else cmd[0]
-
-
-def _inject_macos_ver(env: _MappingT | None) -> _MappingT | dict[str, str | int] | None:
-    if platform.system() != 'Darwin':
-        return env
-
-    from .util import MACOSX_VERSION_VAR, get_macosx_target_ver
-
-    target_ver = get_macosx_target_ver()
-    update = {MACOSX_VERSION_VAR: target_ver} if target_ver else {}
-    return {**_resolve(env), **update}
-
-
-@overload
-def _resolve(env: None) -> os._Environ[str]: ...
-@overload
-def _resolve(env: _MappingT) -> _MappingT: ...
-def _resolve(env: _MappingT | None) -> _MappingT | os._Environ[str]:
-    return os.environ if env is None else env
-
-
-def spawn(
-    cmd: MutableSequence[bytes | str | os.PathLike[str]],
-    search_path: bool = True,
-    verbose: bool = False,
-    dry_run: bool = False,
-    env: _ENV | None = None,
-) -> None:
+def spawn(cmd, search_path=1, verbose=0, dry_run=0, env=None):  # noqa: C901
     """Run another program, specified as a command list 'cmd', in a new process.
 
     'cmd' is just the argument list for the new process, ie.
@@ -74,36 +31,53 @@ def spawn(
     Raise DistutilsExecError if running the program fails in any way; just
     return on success.
     """
+    # cmd is documented as a list, but just in case some code passes a tuple
+    # in, protect our %-formatting code against horrible death
+    cmd = list(cmd)
+
     log.info(subprocess.list2cmdline(cmd))
     if dry_run:
         return
 
     if search_path:
-        executable = shutil.which(cmd[0])
+        executable = find_executable(cmd[0])
         if executable is not None:
             cmd[0] = executable
 
+    env = env if env is not None else dict(os.environ)
+
+    if sys.platform == 'darwin':
+        from distutils.util import MACOSX_VERSION_VAR, get_macosx_target_ver
+
+        macosx_target_ver = get_macosx_target_ver()
+        if macosx_target_ver:
+            env[MACOSX_VERSION_VAR] = macosx_target_ver
+
     try:
-        subprocess.check_call(cmd, env=_inject_macos_ver(env))
+        proc = subprocess.Popen(cmd, env=env)
+        proc.wait()
+        exitcode = proc.returncode
     except OSError as exc:
+        if not DEBUG:
+            cmd = cmd[0]
         raise DistutilsExecError(
-            f"command {_debug(cmd)!r} failed: {exc.args[-1]}"
+            "command {!r} failed: {}".format(cmd, exc.args[-1])
         ) from exc
-    except subprocess.CalledProcessError as err:
+
+    if exitcode:
+        if not DEBUG:
+            cmd = cmd[0]
         raise DistutilsExecError(
-            f"command {_debug(cmd)!r} failed with exit code {err.returncode}"
-        ) from err
+            "command {!r} failed with exit code {}".format(cmd, exitcode)
+        )
 
 
-def find_executable(executable: str, path: str | None = None) -> str | None:
+def find_executable(executable, path=None):
     """Tries to find 'executable' in the directories listed in 'path'.
 
     A string listing directories separated by 'os.pathsep'; defaults to
     os.environ['PATH'].  Returns the complete filename or None if not found.
     """
-    warnings.warn(
-        'Use shutil.which instead of find_executable', DeprecationWarning, stacklevel=2
-    )
     _, ext = os.path.splitext(executable)
     if (sys.platform == 'win32') and (ext != '.exe'):
         executable = executable + '.exe'
@@ -113,13 +87,14 @@ def find_executable(executable: str, path: str | None = None) -> str | None:
 
     if path is None:
         path = os.environ.get('PATH', None)
-        # bpo-35755: Don't fall through if PATH is the empty string
         if path is None:
             try:
                 path = os.confstr("CS_PATH")
             except (AttributeError, ValueError):
                 # os.confstr() or CS_PATH is not available
                 path = os.defpath
+        # bpo-35755: Don't use os.defpath if the PATH environment variable is
+        # set to an empty string
 
     # PATH='' doesn't match, whereas PATH=':' looks in the current directory
     if not path: