relenv 0.21.1__py3-none-any.whl → 0.22.0__py3-none-any.whl

relenv/runtime.py

@@ -1,5 +1,5 @@
 # Copyright 2022-2025 Broadcom.
-# SPDX-License-Identifier: Apache-2
+# SPDX-License-Identifier: Apache-2.0
 """
 This code is run when initializing the python interperter in a Relenv environment.
 
@@ -10,19 +10,61 @@ This code is run when initializing the python interperter in a Relenv environmen
   gcc. This ensures when using pip any c dependencies are compiled against the
   proper glibc version.
 """
+from __future__ import annotations
+
 import contextlib
-import ctypes
+import ctypes as _ctypes
 import functools
-import importlib
-import json
+import importlib as _importlib
+import json as _json
 import os
 import pathlib
-import shutil
-import site
-import subprocess
-import sys
+import shutil as _shutil
+import site as _site
+import subprocess as _subprocess
+import sys as _sys
 import textwrap
-import warnings
+import warnings as _warnings
+from importlib.machinery import ModuleSpec
+from types import ModuleType
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+)
+
+# The tests monkeypatch these module-level imports (e.g., json.loads) inside
+# relenv.runtime itself; keeping them as Any both preserves test isolation—no
+# need to patch the global stdlib modules—and avoids mypy attr-defined noise
+# while still exercising the real runtime wiring.
+json = cast(Any, _json)
+importlib = cast(Any, _importlib)
+site = cast(Any, _site)
+subprocess = cast(Any, _subprocess)
+sys = cast(Any, _sys)
+ctypes = cast(Any, _ctypes)
+shutil = cast(Any, _shutil)
+warnings = cast(Any, _warnings)
+
+__all__ = [
+    "sys",
+    "shutil",
+    "subprocess",
+    "json",
+    "importlib",
+    "site",
+    "ctypes",
+    "warnings",
+]
+
+PathType = Union[str, os.PathLike[str]]
+ConfigVars = Dict[str, str]
 
 # relenv.pth has a __file__ which is set to the path to site.py of the python
 # interpreter being used. We're using that to determine the proper
@@ -32,7 +74,7 @@ import warnings
 # imports happen before our path munghing in site in wrapsitecustomize.
 
 
-def path_import(name, path):
+def path_import(name: str, path: PathType) -> ModuleType:
     """
     Import module from a path.
 
@@ -42,46 +84,50 @@ def path_import(name, path):
     import importlib.util
 
     spec = importlib.util.spec_from_file_location(name, path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Unable to load module {name} from {path}")
     module = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(module)
     sys.modules[name] = module
     return module
 
 
-def common():
-    """
-    Late import relenv common.
-    """
-    if not hasattr(common, "common"):
-        common.common = path_import(
+_COMMON: Optional[ModuleType] = None
+_RELOCATE: Optional[ModuleType] = None
+_BUILDENV: Optional[ModuleType] = None
+
+
+def common() -> ModuleType:
+    """Return the cached ``relenv.common`` module."""
+    global _COMMON
+    if _COMMON is None:
+        _COMMON = path_import(
             "relenv.common", str(pathlib.Path(__file__).parent / "common.py")
         )
-    return common.common
+    return _COMMON
 
 
-def relocate():
-    """
-    Late import relenv relocate.
-    """
-    if not hasattr(relocate, "relocate"):
-        relocate.relocate = path_import(
+def relocate() -> ModuleType:
+    """Return the cached ``relenv.relocate`` module."""
+    global _RELOCATE
+    if _RELOCATE is None:
+        _RELOCATE = path_import(
             "relenv.relocate", str(pathlib.Path(__file__).parent / "relocate.py")
         )
-    return relocate.relocate
+    return _RELOCATE
 
 
-def buildenv():
-    """
-    Late import relenv buildenv.
-    """
-    if not hasattr(buildenv, "builenv"):
-        buildenv.buildenv = path_import(
+def buildenv() -> ModuleType:
+    """Return the cached ``relenv.buildenv`` module."""
+    global _BUILDENV
+    if _BUILDENV is None:
+        _BUILDENV = path_import(
             "relenv.buildenv", str(pathlib.Path(__file__).parent / "buildenv.py")
         )
-    return buildenv.buildenv
+    return _BUILDENV
 
 
-def get_major_version():
+def get_major_version() -> str:
     """
     Current python major version.
     """
@@ -89,7 +135,7 @@ def get_major_version():
 
 
 @contextlib.contextmanager
-def pushd(new_dir):
+def pushd(new_dir: PathType) -> Iterator[None]:
     """
     Changedir context.
     """
@@ -101,7 +147,7 @@ def pushd(new_dir):
         os.chdir(old_dir)
 
 
-def debug(string):
+def debug(string: str) -> None:
     """
     Prints the provided message if RELENV_DEBUG is truthy in the environment.
 
@@ -113,7 +159,7 @@ def debug(string):
         sys.stdout.flush()
 
 
-def relenv_root():
+def relenv_root() -> pathlib.Path:
     """
     Return the relenv module root.
     """
@@ -126,7 +172,9 @@ def relenv_root():
     return MODULE_DIR.parent.parent.parent.parent
 
 
-def _build_shebang(func, *args, **kwargs):
+def _build_shebang(
+    func: Callable[..., bytes], *args: Any, **kwargs: Any
+) -> Callable[..., bytes]:
     """
     Build a shebang to point to the proper location.
 
@@ -135,34 +183,37 @@ def _build_shebang(func, *args, **kwargs):
     """
 
     @functools.wraps(func)
-    def wrapped(self, *args, **kwargs):
+    def wrapped(self: Any, *args: Any, **kwargs: Any) -> bytes:
         scripts = pathlib.Path(self.target_dir)
         if TARGET.TARGET:
-            scripts = pathlib.Path(TARGET.PATH).absolute() / "bin"
+            scripts = pathlib.Path(_ensure_target_path()).absolute() / "bin"
         try:
             interpreter = common().relative_interpreter(
                 sys.RELENV, scripts, pathlib.Path(sys.executable).resolve()
             )
         except ValueError:
             debug(f"Relenv Value Error - _build_shebang {self.target_dir}")
-            return func(self, *args, **kwargs)
+            original_result: bytes = func(self, *args, **kwargs)
+            return original_result
         debug(f"Relenv - _build_shebang {scripts} {interpreter}")
         if sys.platform == "win32":
             return (
                 str(pathlib.Path("#!<launcher_dir>") / interpreter).encode() + b"\r\n"
             )
-        return common().format_shebang("/" / interpreter).encode()
+        rel_path = str(pathlib.PurePosixPath("/") / interpreter)
+        formatted = cast(str, common().format_shebang(rel_path))
+        return formatted.encode()
 
     return wrapped
 
 
-def get_config_var_wrapper(func):
+def get_config_var_wrapper(func: Callable[[str], Any]) -> Callable[[str], Any]:
     """
     Return a wrapper to resolve paths relative to the relenv root.
     """
 
     @functools.wraps(func)
-    def wrapped(name):
+    def wrapped(name: str) -> Any:
         if name == "BINDIR":
             orig = func(name)
             if os.environ.get("RELENV_PIP_DIR"):
@@ -179,13 +230,13 @@ def get_config_var_wrapper(func):
     return wrapped
 
 
-_CONFIG_VARS_DEFAULTS = {
+CONFIG_VARS_DEFAULTS: ConfigVars = {
     "AR": "ar",
     "CC": "gcc",
     "CFLAGS": "-Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall",
     "CPPFLAGS": "-I. -I./Include",
     "CXX": "g++",
-    "LIBDEST": "/usr/local/lib/python3.8",
+    "LIBDEST": "/usr/local/lib/python3.10",
     "SCRIPTDIR": "/usr/local/lib",
     "BLDSHARED": "gcc -shared",
     "LDFLAGS": "",
@@ -193,10 +244,10 @@ _CONFIG_VARS_DEFAULTS = {
     "LDSHARED": "gcc -shared",
 }
 
-_SYSTEM_CONFIG_VARS = None
+_SYSTEM_CONFIG_VARS: Optional[ConfigVars] = None
 
 
-def system_sysconfig():
+def system_sysconfig() -> ConfigVars:
     """
     Read the system python's sysconfig values.
 
@@ -204,7 +255,7 @@ def system_sysconfig():
     to avoid the overhead of shelling out.
     """
     global _SYSTEM_CONFIG_VARS
-    if _SYSTEM_CONFIG_VARS:
+    if _SYSTEM_CONFIG_VARS is not None:
         return _SYSTEM_CONFIG_VARS
     pyexec = pathlib.Path("/usr/bin/python3")
     if pyexec.exists():
@@ -220,25 +271,27 @@ def system_sysconfig():
             _SYSTEM_CONFIG_VARS = json.loads(p.stdout.strip())
         except json.JSONDecodeError:
             debug(f"Failed to load JSON from: {p.stdout.strip()}")
-            _SYSTEM_CONFIG_VARS = _CONFIG_VARS_DEFAULTS
+            _SYSTEM_CONFIG_VARS = CONFIG_VARS_DEFAULTS
     else:
         debug("System python not found")
-        _SYSTEM_CONFIG_VARS = _CONFIG_VARS_DEFAULTS
+        _SYSTEM_CONFIG_VARS = CONFIG_VARS_DEFAULTS
     return _SYSTEM_CONFIG_VARS
 
 
-def get_config_vars_wrapper(func, mod):
+def get_config_vars_wrapper(
+    func: Callable[..., ConfigVars], mod: ModuleType
+) -> Callable[..., ConfigVars]:
     """
     Return a wrapper to resolve paths relative to the relenv root.
     """
 
     @functools.wraps(func)
-    def wrapped(*args):
+    def wrapped(*args: Any) -> ConfigVars:
         if sys.platform == "win32" or "RELENV_BUILDENV" in os.environ:
             return func(*args)
 
-        _CONFIG_VARS = func()
-        _SYSTEM_CONFIG_VARS = system_sysconfig()
+        config_vars = func()
+        system_config_vars = system_sysconfig()
         for name in [
             "AR",
             "CC",
@@ -252,20 +305,26 @@ def get_config_vars_wrapper(func, mod):
             "LDCXXSHARED",
             "LDSHARED",
         ]:
-            _CONFIG_VARS[name] = _SYSTEM_CONFIG_VARS[name]
-        mod._CONFIG_VARS = _CONFIG_VARS
+            config_vars[name] = system_config_vars[name]
+        setattr(mod, "_CONFIG_VARS", config_vars)
         return func(*args)
 
     return wrapped
 
 
-def get_paths_wrapper(func, default_scheme):
+def get_paths_wrapper(
+    func: Callable[..., Dict[str, str]], default_scheme: str
+) -> Callable[..., Dict[str, str]]:
     """
     Return a wrapper to resolve paths relative to the relenv root.
     """
 
     @functools.wraps(func)
-    def wrapped(scheme=default_scheme, vars=None, expand=True):
+    def wrapped(
+        scheme: Optional[str] = default_scheme,
+        vars: Optional[Dict[str, str]] = None,
+        expand: bool = True,
+    ) -> Dict[str, str]:
         paths = func(scheme=scheme, vars=vars, expand=expand)
         if "RELENV_PIP_DIR" in os.environ:
             paths["scripts"] = str(relenv_root())
@@ -275,7 +334,7 @@ def get_paths_wrapper(func, default_scheme):
     return wrapped
 
 
-def finalize_options_wrapper(func):
+def finalize_options_wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
     """
     Wrapper around build_ext.finalize_options.
 
@@ -283,15 +342,15 @@ def finalize_options_wrapper(func):
     """
 
     @functools.wraps(func)
-    def wrapper(self, *args, **kwargs):
+    def wrapper(self: Any, *args: Any, **kwargs: Any) -> None:
         func(self, *args, **kwargs)
         if "RELENV_BUILDENV" in os.environ:
-            self.include_dirs.append(f"{relenv_root()}/include")
+            self.include_dirs.append(str(relenv_root() / "include"))
 
     return wrapper
 
 
-def install_wheel_wrapper(func):
+def install_wheel_wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
     """
     Wrap pip's wheel install function.
 
@@ -300,15 +359,15 @@ def install_wheel_wrapper(func):
 
     @functools.wraps(func)
     def wrapper(
-        name,
-        wheel_path,
-        scheme,
-        req_description,
-        pycompile,
-        warn_script_location,
-        direct_url,
-        requested,
-    ):
+        name: str,
+        wheel_path: PathType,
+        scheme: Any,
+        req_description: str,
+        pycompile: Any,
+        warn_script_location: Any,
+        direct_url: Any,
+        requested: Any,
+    ) -> Any:
         from zipfile import ZipFile
 
         from pip._internal.utils.wheel import parse_wheel
@@ -348,7 +407,7 @@ def install_wheel_wrapper(func):
     return wrapper
 
 
-def install_legacy_wrapper(func):
+def install_legacy_wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
     """
     Wrap pip's legacy install function.
 
@@ -359,21 +418,21 @@ def install_legacy_wrapper(func):
 
     @functools.wraps(func)
     def wrapper(
-        install_options,
-        global_options,
-        root,
-        home,
-        prefix,
-        use_user_site,
-        pycompile,
-        scheme,
-        setup_py_path,
-        isolated,
-        req_name,
-        build_env,
-        unpacked_source_directory,
-        req_description,
-    ):
+        install_options: Any,
+        global_options: Any,
+        root: Any,
+        home: Any,
+        prefix: Any,
+        use_user_site: Any,
+        pycompile: Any,
+        scheme: Any,
+        setup_py_path: Any,
+        isolated: Any,
+        req_name: Any,
+        build_env: Any,
+        unpacked_source_directory: Any,
+        req_description: Any,
+    ) -> Any:
 
         pkginfo = pathlib.Path(setup_py_path).parent / "PKG-INFO"
         with open(pkginfo) as fp:
@@ -447,13 +506,19 @@ class Wrapper:
     Wrap methods of an imported module.
     """
 
-    def __init__(self, module, wrapper, matcher="equals", _loading=False):
+    def __init__(
+        self,
+        module: str,
+        wrapper: Callable[[str], ModuleType],
+        matcher: str = "equals",
+        _loading: bool = False,
+    ) -> None:
         self.module = module
         self.wrapper = wrapper
         self.matcher = matcher
         self.loading = _loading
 
-    def matches(self, module):
+    def matches(self: "Wrapper", module: str) -> bool:
         """
         Check if wrapper metches module being imported.
         """
@@ -461,7 +526,7 @@ class Wrapper:
             return module.startswith(self.module)
         return self.module == module
 
-    def __call__(self, module_name):
+    def __call__(self: "Wrapper", module_name: str) -> ModuleType:
         """
         Preform the wrapper operation.
         """
@@ -473,15 +538,24 @@ class RelenvImporter:
     Handle runtime wrapping of module methods.
     """
 
-    def __init__(self, wrappers=None, _loads=None):
+    def __init__(
+        self,
+        wrappers: Optional[Iterable[Wrapper]] = None,
+        _loads: Optional[Dict[str, ModuleType]] = None,
+    ) -> None:
         if wrappers is None:
             wrappers = []
-        self.wrappers = set(wrappers)
+        self.wrappers: set[Wrapper] = set(wrappers)
         if _loads is None:
             _loads = {}
-        self._loads = _loads
-
-    def find_spec(self, module_name, package_path=None, target=None):
+        self._loads: Dict[str, ModuleType] = _loads
+
+    def find_spec(
+        self: "RelenvImporter",
+        module_name: str,
+        package_path: Optional[Sequence[str]] = None,
+        target: Any = None,
+    ) -> Optional[ModuleSpec]:
         """
         Find modules being imported.
         """
@@ -489,9 +563,15 @@ class RelenvImporter:
             if wrapper.matches(module_name) and not wrapper.loading:
                 debug(f"RelenvImporter - match {module_name} {package_path} {target}")
                 wrapper.loading = True
-                return importlib.util.spec_from_loader(module_name, self)
+                spec = importlib.util.spec_from_loader(module_name, self)
+                return cast(Optional[ModuleSpec], spec)
+        return None
 
-    def find_module(self, module_name, package_path=None):
+    def find_module(
+        self: "RelenvImporter",
+        module_name: str,
+        package_path: Optional[Sequence[str]] = None,
+    ) -> Optional["RelenvImporter"]:
         """
         Find modules being imported.
         """
@@ -500,38 +580,43 @@ class RelenvImporter:
                 debug(f"RelenvImporter - match {module_name}")
                 wrapper.loading = True
                 return self
+        return None
 
-    def load_module(self, name):
+    def load_module(self: "RelenvImporter", name: str) -> ModuleType:
         """
         Load an imported module.
         """
+        mod: Optional[ModuleType] = None
         for wrapper in self.wrappers:
             if wrapper.matches(name):
                 debug(f"RelenvImporter - load_module {name}")
                 mod = wrapper(name)
                 wrapper.loading = False
                 break
+        if mod is None:
+            mod = importlib.import_module(name)
         sys.modules[name] = mod
         return mod
 
-    def create_module(self, spec):
+    def create_module(self: "RelenvImporter", spec: ModuleSpec) -> Optional[ModuleType]:
         """
         Create the module via a spec.
         """
         return self.load_module(spec.name)
 
-    def exec_module(self, module):
+    def exec_module(self: "RelenvImporter", module: ModuleType) -> None:
         """
         Exec module noop.
         """
         return None
 
 
-def wrap_sysconfig(name):
+def wrap_sysconfig(name: str) -> ModuleType:
     """
     Sysconfig wrapper.
     """
-    mod = importlib.import_module("sysconfig")
+    module: ModuleType = importlib.import_module("sysconfig")
+    mod = cast(Any, module)
     mod.get_config_var = get_config_var_wrapper(mod.get_config_var)
     mod.get_config_vars = get_config_vars_wrapper(mod.get_config_vars, mod)
     mod._PIP_USE_SYSCONFIG = True
@@ -542,48 +627,52 @@ def wrap_sysconfig(name):
         # Python < 3.10
         scheme = mod._get_default_scheme()
     mod.get_paths = get_paths_wrapper(mod.get_paths, scheme)
-    return mod
+    return module
 
 
-def wrap_pip_distlib_scripts(name):
+def wrap_pip_distlib_scripts(name: str) -> ModuleType:
     """
     pip.distlib.scripts wrapper.
     """
-    mod = importlib.import_module(name)
+    module: ModuleType = importlib.import_module(name)
+    mod = cast(Any, module)
     mod.ScriptMaker._build_shebang = _build_shebang(mod.ScriptMaker._build_shebang)
-    return mod
+    return module
 
 
-def wrap_distutils_command(name):
+def wrap_distutils_command(name: str) -> ModuleType:
     """
     distutils.command wrapper.
     """
-    mod = importlib.import_module(name)
+    module: ModuleType = importlib.import_module(name)
+    mod = cast(Any, module)
     mod.build_ext.finalize_options = finalize_options_wrapper(
         mod.build_ext.finalize_options
     )
-    return mod
+    return module
 
 
-def wrap_pip_install_wheel(name):
+def wrap_pip_install_wheel(name: str) -> ModuleType:
     """
     pip._internal.operations.install.wheel wrapper.
     """
-    mod = importlib.import_module(name)
+    module: ModuleType = importlib.import_module(name)
+    mod = cast(Any, module)
     mod.install_wheel = install_wheel_wrapper(mod.install_wheel)
-    return mod
+    return module
 
 
-def wrap_pip_install_legacy(name):
+def wrap_pip_install_legacy(name: str) -> ModuleType:
     """
     pip._internal.operations.install.legacy wrapper.
     """
-    mod = importlib.import_module(name)
+    module: ModuleType = importlib.import_module(name)
+    mod = cast(Any, module)
     mod.install = install_legacy_wrapper(mod.install)
-    return mod
+    return module
 
 
-def set_env_if_not_set(name, value):
+def set_env_if_not_set(name: str, value: str) -> None:
     """
     Set an environment variable if not already set.
 
@@ -600,21 +689,21 @@ def set_env_if_not_set(name, value):
         os.environ[name] = value
 
 
-def wrap_pip_build_wheel(name):
+def wrap_pip_build_wheel(name: str) -> ModuleType:
     """
     pip._internal.operations.build wrapper.
     """
-    mod = importlib.import_module(name)
+    module: ModuleType = importlib.import_module(name)
+    mod = cast(Any, module)
 
-    def wrap(func):
+    def wrap(func: Callable[..., Any]) -> Callable[..., Any]:
         @functools.wraps(func)
-        def wrapper(*args, **kwargs):
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
             if sys.platform != "linux":
                 return func(*args, **kwargs)
-            base_dir = common().DATA_DIR / "toolchain"
-            toolchain = base_dir / common().get_triplet()
+            toolchain = common().get_toolchain()
             cargo_home = str(common().DATA_DIR / "cargo")
-            if not toolchain.exists():
+            if toolchain is None or not toolchain.exists():
                 debug("Unable to set CARGO_HOME no toolchain exists")
             else:
                 relenvroot = str(sys.RELENV)
@@ -631,7 +720,7 @@ def wrap_pip_build_wheel(name):
         return wrapper
 
     mod.build_wheel_pep517 = wrap(mod.build_wheel_pep517)
-    return mod
+    return module
 
 
 class TARGET:
@@ -639,21 +728,31 @@ class TARGET:
     Container for global pip target state.
     """
 
-    TARGET = False
-    TARGET_PATH = None
-    IGNORE = False
-    INSTALL = False
+    TARGET: bool = False
+    PATH: Optional[str] = None
+    IGNORE: bool = False
+    INSTALL: bool = False
+
+
+def _ensure_target_path() -> str:
+    """
+    Return the stored target path, raising if it is unavailable.
+    """
+    if TARGET.PATH is None:
+        raise RuntimeError("TARGET path requested but not initialized")
+    return TARGET.PATH
 
 
-def wrap_cmd_install(name):
+def wrap_cmd_install(name: str) -> ModuleType:
     """
     Wrap pip install command to store target argument state.
     """
-    mod = importlib.import_module(name)
+    module: ModuleType = importlib.import_module(name)
+    mod = cast(Any, module)
 
-    def wrap(func):
+    def wrap_run(func: Callable[..., Any]) -> Callable[..., Any]:
         @functools.wraps(func)
-        def wrapper(self, options, args):
+        def wrapper(self: Any, options: Any, args: Sequence[str]) -> Any:
             if not options.use_user_site:
                 if options.target_dir:
                     TARGET.TARGET = True
@@ -663,11 +762,13 @@ def wrap_cmd_install(name):
 
         return wrapper
 
-    mod.InstallCommand.run = wrap(mod.InstallCommand.run)
+    mod.InstallCommand.run = wrap_run(mod.InstallCommand.run)
 
-    def wrap(func):
+    def wrap_handle_target(func: Callable[..., Any]) -> Callable[..., Any]:
         @functools.wraps(func)
-        def wrapper(self, target_dir, target_temp_dir, upgrade):
+        def wrapper(
+            self: Any, target_dir: str, target_temp_dir: str, upgrade: bool
+        ) -> int:
             from pip._internal.cli.status_codes import SUCCESS
 
             return SUCCESS
@@ -675,30 +776,37 @@ def wrap_cmd_install(name):
         return wrapper
 
     if hasattr(mod.InstallCommand, "_handle_target_dir"):
-        mod.InstallCommand._handle_target_dir = wrap(
+        mod.InstallCommand._handle_target_dir = wrap_handle_target(
             mod.InstallCommand._handle_target_dir
         )
-    return mod
+    return module
 
 
-def wrap_locations(name):
+def wrap_locations(name: str) -> ModuleType:
     """
     Wrap pip locations to fix locations when installing with target.
     """
-    mod = importlib.import_module(name)
+    module: ModuleType = importlib.import_module(name)
+    mod = cast(Any, module)
 
-    def wrap(func):
+    def make_scheme_wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
         @functools.wraps(func)
         def wrapper(
-            dist_name, user=False, home=None, root=None, isolated=False, prefix=None
-        ):
+            dist_name: str,
+            user: bool = False,
+            home: Optional[PathType] = None,
+            root: Optional[PathType] = None,
+            isolated: bool = False,
+            prefix: Optional[PathType] = None,
+        ) -> Any:
             scheme = func(dist_name, user, home, root, isolated, prefix)
             if TARGET.TARGET and TARGET.INSTALL:
                 from pip._internal.models.scheme import Scheme
 
+                target_path = _ensure_target_path()
                 scheme = Scheme(
-                    platlib=TARGET.PATH,
-                    purelib=TARGET.PATH,
+                    platlib=target_path,
+                    purelib=target_path,
                     headers=scheme.headers,
                     scripts=scheme.scripts,
                     data=scheme.data,
@@ -709,113 +817,179 @@ def wrap_locations(name):
 
     # get_scheme is not available on pip-19.2.3
     # try:
-    mod.get_scheme = wrap(mod.get_scheme)
+    mod.get_scheme = make_scheme_wrapper(mod.get_scheme)
     # except AttributeError:
     #    debug(f"Module {mod} does not have attribute get_scheme")
 
-    return mod
+    return module
 
 
-def wrap_req_command(name):
+def wrap_req_command(name: str) -> ModuleType:
     """
     Honor ignore installed option from pip cli.
     """
-    mod = importlib.import_module(name)
+    module: ModuleType = importlib.import_module(name)
+    mod = cast(Any, module)
 
-    def wrap(func):
+    def make_package_finder_wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
         @functools.wraps(func)
         def wrapper(
-            self,
-            options,
-            session,
-            target_python=None,
-            ignore_requires_python=None,
-        ):
+            self: Any,
+            options: Any,
+            session: Any,
+            target_python: Any = None,
+            ignore_requires_python: Any = None,
+        ) -> Any:
             if TARGET.TARGET:
                 options.ignore_installed = TARGET.IGNORE
             return func(self, options, session, target_python, ignore_requires_python)
 
         return wrapper
 
-    mod.RequirementCommand._build_package_finder = wrap(
+    mod.RequirementCommand._build_package_finder = make_package_finder_wrapper(
         mod.RequirementCommand._build_package_finder
     )
-    return mod
+    return module
 
 
-def wrap_req_install(name):
+def wrap_req_install(name: str) -> ModuleType:
     """
     Honor ignore installed option from pip cli.
     """
-    mod = importlib.import_module(name)
-
-    def wrap(func):
-        if mod.InstallRequirement.install.__code__.co_argcount == 9:
-
-            @functools.wraps(func)
-            def wrapper(
-                self,
-                install_options,
-                global_options=None,
-                root=None,
-                home=None,
-                prefix=None,
-                warn_script_location=True,
-                use_user_site=False,
-                pycompile=True,
-            ):
-                try:
-                    if TARGET.TARGET:
-                        TARGET.INSTALL = True
-                        home = TARGET.PATH
-                    return func(
-                        self,
-                        install_options,
-                        global_options,
-                        root,
-                        home,
-                        prefix,
-                        warn_script_location,
-                        use_user_site,
-                        pycompile,
-                    )
-                finally:
-                    TARGET.INSTALL = False
+    module: ModuleType = importlib.import_module(name)
+    mod = cast(Any, module)
 
-        else:
+    original = mod.InstallRequirement.install
+    argcount = original.__code__.co_argcount
 
-            @functools.wraps(func)
-            def wrapper(
-                self,
-                global_options=None,
-                root=None,
-                home=None,
-                prefix=None,
-                warn_script_location=True,
-                use_user_site=False,
-                pycompile=True,
-            ):
-                try:
-                    if TARGET.TARGET:
-                        TARGET.INSTALL = True
-                        home = TARGET.PATH
-                    return func(
-                        self,
-                        global_options,
-                        root,
-                        home,
-                        prefix,
-                        warn_script_location,
-                        use_user_site,
-                        pycompile,
-                    )
-                finally:
-                    TARGET.INSTALL = False
+    if argcount == 7:
 
-        return wrapper
+        @functools.wraps(original)
+        def install_wrapper_pep517(
+            self: Any,
+            root: Optional[PathType] = None,
+            home: Optional[PathType] = None,
+            prefix: Optional[PathType] = None,
+            warn_script_location: bool = True,
+            use_user_site: bool = False,
+            pycompile: bool = True,
+        ) -> Any:
+            try:
+                if TARGET.TARGET:
+                    TARGET.INSTALL = True
+                    home = _ensure_target_path()
+                return original(
+                    self,
+                    root,
+                    home,
+                    prefix,
+                    warn_script_location,
+                    use_user_site,
+                    pycompile,
+                )
+            finally:
+                TARGET.INSTALL = False
+
+        mod.InstallRequirement.install = install_wrapper_pep517
+
+    elif argcount == 8:
+
+        @functools.wraps(original)
+        def install_wrapper_pep517_opts(
+            self: Any,
+            global_options: Any = None,
+            root: Optional[PathType] = None,
+            home: Optional[PathType] = None,
+            prefix: Optional[PathType] = None,
+            warn_script_location: bool = True,
+            use_user_site: bool = False,
+            pycompile: bool = True,
+        ) -> Any:
+            try:
+                if TARGET.TARGET:
+                    TARGET.INSTALL = True
+                    home = _ensure_target_path()
+                return original(
+                    self,
+                    global_options,
+                    root,
+                    home,
+                    prefix,
+                    warn_script_location,
+                    use_user_site,
+                    pycompile,
+                )
+            finally:
+                TARGET.INSTALL = False
+
+        mod.InstallRequirement.install = install_wrapper_pep517_opts
+
+    elif argcount == 9:
+
+        @functools.wraps(original)
+        def install_wrapper_legacy(
+            self: Any,
+            install_options: Any,
+            global_options: Any = None,
+            root: Optional[PathType] = None,
+            home: Optional[PathType] = None,
+            prefix: Optional[PathType] = None,
+            warn_script_location: bool = True,
+            use_user_site: bool = False,
+            pycompile: bool = True,
+        ) -> Any:
+            try:
+                if TARGET.TARGET:
+                    TARGET.INSTALL = True
+                    home = _ensure_target_path()
+                return original(
+                    self,
+                    install_options,
+                    global_options,
+                    root,
+                    home,
+                    prefix,
+                    warn_script_location,
+                    use_user_site,
+                    pycompile,
+                )
+            finally:
+                TARGET.INSTALL = False
+
+        mod.InstallRequirement.install = install_wrapper_legacy
+
+    else:
+
+        @functools.wraps(original)
+        def install_wrapper_generic(
+            self: Any,
+            global_options: Any = None,
+            root: Optional[PathType] = None,
+            home: Optional[PathType] = None,
+            prefix: Optional[PathType] = None,
+            warn_script_location: bool = True,
+            use_user_site: bool = False,
+            pycompile: bool = True,
+        ) -> Any:
+            try:
+                if TARGET.TARGET:
+                    TARGET.INSTALL = True
+                    home = _ensure_target_path()
+                return original(
+                    self,
+                    global_options,
+                    root,
+                    home,
+                    prefix,
+                    warn_script_location,
+                    use_user_site,
+                    pycompile,
+                )
+            finally:
+                TARGET.INSTALL = False
 
-    mod.InstallRequirement.install = wrap(mod.InstallRequirement.install)
-    return mod
+        mod.InstallRequirement.install = install_wrapper_generic
+    return module
 
 
 importer = RelenvImporter(
@@ -834,7 +1008,7 @@ importer = RelenvImporter(
 )
 
 
-def install_cargo_config():
+def install_cargo_config() -> None:
     """
     Setup cargo config.
     """
@@ -845,8 +1019,8 @@ def install_cargo_config():
     # load the ssl module. Causing out setup_openssl method to fail to load
     # fips module.
     dirs = common().work_dirs()
-    triplet = common().get_triplet()
     cargo_home = dirs.data / "cargo"
+    triplet = common().get_triplet()
 
     toolchain = common().get_toolchain()
     if not toolchain:
@@ -858,27 +1032,46 @@ def install_cargo_config():
         return
 
     # cargo_home = dirs.data / "cargo"
-    if not cargo_home.exists():
-        cargo_home.mkdir()
+    cargo_home.mkdir(parents=True, exist_ok=True)
     cargo_config = cargo_home / "config.toml"
-    if not cargo_config.exists():
-        if triplet == "x86_64-linux-gnu":
-            cargo_triplet = "x86_64-unknown-linux-gnu"
-        else:
-            cargo_triplet = "aarch64-unknown-linux-gnu"
-        gcc = toolchain / "bin" / f"{triplet}-gcc"
-        with open(cargo_config, "w") as fp:
-            fp.write(
-                textwrap.dedent(
-                    """\
-            [target.{}]
-            linker = "{}"
+    if triplet == "x86_64-linux-gnu":
+        cargo_triplet = "x86_64-unknown-linux-gnu"
+    else:
+        cargo_triplet = "aarch64-unknown-linux-gnu"
+    gcc = toolchain / "bin" / f"{triplet}-gcc"
+
+    def existing_linker() -> str | None:
+        if not cargo_config.exists():
+            return None
+        try:
+            contents = cargo_config.read_text()
+        except OSError:
+            return None
+        marker = f"[target.{cargo_triplet}]"
+        if marker not in contents:
+            return None
+        for line in contents.splitlines():
+            stripped = line.strip()
+            if stripped.startswith("linker"):
+                value_part: str
+                _, _, value_part = stripped.partition("=")
+                value_str: str = value_part.strip().strip('"')
+                if value_str:
+                    return value_str
+        return None
+
+    if existing_linker() != str(gcc):
+        cargo_config.write_text(
+            textwrap.dedent(
+                """\
+            [target.{triplet}]
+            linker = "{linker}"
             """
-                ).format(cargo_triplet, gcc)
-            )
+            ).format(triplet=cargo_triplet, linker=gcc)
+        )
 
 
-def setup_openssl():
+def setup_openssl() -> None:
     """
     Configure openssl certificate locations.
     """
@@ -918,7 +1111,7 @@ def setup_openssl():
             debug(msg)
         else:
             try:
-                _, directory = proc.stdout.split(":")
+                _, directory = proc.stdout.split(":", 1)
             except ValueError:
                 debug("Unable to parse modules dir")
                 return
@@ -952,7 +1145,7 @@ def setup_openssl():
             debug(msg)
         else:
             try:
-                _, directory = proc.stdout.split(":")
+                _, directory = proc.stdout.split(":", 1)
             except ValueError:
                 debug("Unable to parse openssldir")
                 return
@@ -964,7 +1157,7 @@ def setup_openssl():
                 os.environ["SSL_CERT_FILE"] = str(cert_file)
 
 
-def set_openssl_modules_dir(path):
+def set_openssl_modules_dir(path: str) -> None:
     """
     Set the default search location for openssl modules.
     """
@@ -982,7 +1175,7 @@ def set_openssl_modules_dir(path):
     OSSL_PROVIDER_set_default_search_path(None, path.encode())
 
 
-def load_openssl_provider(name):
+def load_openssl_provider(name: str) -> int:
     """
     Load an openssl module.
     """
@@ -995,10 +1188,11 @@ def load_openssl_provider(name):
     OSSL_PROVIDER_load = libcrypto.OSSL_PROVIDER_load
     OSSL_PROVIDER_load.argtypes = (POSSL_LIB_CTX, ctypes.c_char_p)
     OSSL_PROVIDER_load.restype = ctypes.c_int
-    return OSSL_PROVIDER_load(None, name.encode())
+    result = OSSL_PROVIDER_load(None, name.encode())
+    return int(result)
 
 
-def setup_crossroot():
+def setup_crossroot() -> None:
     """
     Setup cross root if needed.
     """
@@ -1016,7 +1210,7 @@ def setup_crossroot():
         ] + [_ for _ in sys.path if "site-packages" not in _]
 
 
-def wrapsitecustomize(func):
+def wrapsitecustomize(func: Callable[[], Any]) -> Callable[[], None]:
     """
     Wrap site.execsitecustomize.
 
@@ -1025,12 +1219,14 @@ def wrapsitecustomize(func):
     """
 
     @functools.wraps(func)
-    def wrapper():
+    def wrapper() -> None:
         func()
 
-        sitecustomize = None
+        sitecustomize_module = None
         try:
-            import sitecustomize
+            import sitecustomize as _sitecustomize
+
+            sitecustomize_module = _sitecustomize
         except ImportError as exc:
             if exc.name != "sitecustomize":
                 raise
@@ -1039,7 +1235,10 @@ def wrapsitecustomize(func):
         # relenv environment. This can't be done when pip is using build_env to
         # install packages. This code seems potentially brittle and there may
         # be reasonable arguments against doing it at all.
-        if sitecustomize is None or "pip-build-env" not in sitecustomize.__file__:
+        if (
+            sitecustomize_module is None
+            or "pip-build-env" not in sitecustomize_module.__file__
+        ):
             _orig = sys.path[:]
             # Replace sys.path
             sys.path[:] = common().sanitize_sys_path(sys.path)
@@ -1054,7 +1253,7 @@ def wrapsitecustomize(func):
     return wrapper
 
 
-def bootstrap():
+def bootstrap() -> None:
     """
     Bootstrap the relenv environment.
     """