More conversions to pathlib to help with the pythonfinder integration

Author: matteius

pipenv/__init__.py

@@ -2,11 +2,12 @@
 import os
 import sys
 import warnings
+from pathlib import Path
 
 # This has to come before imports of pipenv
-PIPENV_ROOT = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
-PIP_ROOT = os.sep.join([PIPENV_ROOT, "patched", "pip"])
-sys.path.insert(0, PIPENV_ROOT)
+PIPENV_ROOT = Path(__file__).resolve().parent.absolute()
+PIP_ROOT = str(PIPENV_ROOT / "patched" / "pip")
+sys.path.insert(0, str(PIPENV_ROOT))
 sys.path.insert(0, PIP_ROOT)
 
 # Load patched pip instead of system pip
@@ -15,9 +16,10 @@
 
 def _ensure_modules():
     # Ensure when pip gets invoked it uses our patched version
+    location = Path(__file__).parent / "patched" / "pip" / "__init__.py"
     spec = importlib.util.spec_from_file_location(
         "pip",
-        location=os.path.join(os.path.dirname(__file__), "patched", "pip", "__init__.py"),
+        location=str(location),
     )
     pip = importlib.util.module_from_spec(spec)
     sys.modules["pip"] = pip

pipenv/cli/command.py

@@ -1,5 +1,6 @@
 import os
 import sys
+from pathlib import Path
 
 from pipenv import environments
 from pipenv.__version__ import __version__
@@ -98,8 +99,8 @@ def cli(
 
     if man:
         if system_which("man"):
-            path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "pipenv.1")
-            os.execle(system_which("man"), "man", path, os.environ)
+            path = Path(__file__).parent.parent / "pipenv.1"
+            os.execle(system_which("man"), "man", str(path), os.environ)
             return 0
         else:
             err.print(
@@ -393,8 +394,8 @@ def shell(state, fancy=False, shell_args=None, anyway=False, quiet=False):
     # Use fancy mode for Windows or pwsh on *nix.
     if (
         os.name == "nt"
-        or (os.environ.get("PIPENV_SHELL") or "").split(os.path.sep)[-1] == "pwsh"
-        or (os.environ.get("SHELL") or "").split(os.path.sep)[-1] == "pwsh"
+        or Path(os.environ.get("PIPENV_SHELL") or "").name == "pwsh"
+        or Path(os.environ.get("SHELL") or "").name == "pwsh"
     ):
         fancy = True
     do_shell(
@@ -624,7 +625,7 @@ def run_open(state, module, *args, **kwargs):
         console.print("Module not found!", style="red")
         sys.exit(1)
     if "__init__.py" in c.stdout:
-        p = os.path.dirname(c.stdout.strip().rstrip("cdo"))
+        p = Path(c.stdout.strip().rstrip("cdo")).parent
     else:
         p = c.stdout.strip().rstrip("cdo")
     console.print(f"Opening {p!r} in your EDITOR.", style="bold")

pipenv/cli/options.py

@@ -1,5 +1,5 @@
-import os
 import re
+from pathlib import Path
 
 from pipenv.project import Project
 from pipenv.utils import console, err
@@ -460,7 +460,8 @@ def validate_python_path(ctx, param, value):
     # the path or an absolute path. To report errors as early as possible
     # we'll report absolute paths which do not exist:
     if isinstance(value, (str, bytes)):
-        if os.path.isabs(value) and not os.path.isfile(value):
+        path = Path(value)
+        if path.is_absolute() and not path.is_file():
             raise BadParameter(f"Expected Python at path {value} does not exist")
     return value
 

pipenv/environment.py

@@ -113,7 +113,7 @@ def python_version(self) -> str | None:
     @property
     def python_info(self) -> dict[str, str]:
         include_dir = self.prefix / "include"
-        if not os.path.exists(include_dir):
+        if not include_dir.exists():
             include_dirs = self.get_include_path()
             if include_dirs:
                 include_path = include_dirs.get(
@@ -130,15 +130,17 @@ def python_info(self) -> dict[str, str]:
         return {}
 
     def _replace_parent_version(self, path: str, replace_version: str) -> str:
-        if not os.path.exists(path):
-            base, leaf = os.path.split(path)
-            base, parent = os.path.split(base)
-            leaf = os.path.join(parent, leaf).replace(
+        path_obj = Path(path)
+        if not path_obj.exists():
+            parent = path_obj.parent
+            grandparent = parent.parent
+            leaf = f"{parent.name}/{path_obj.name}"
+            leaf = leaf.replace(
                 replace_version,
                 self.python_info.get("py_version_short", get_python_version()),
             )
-            return os.path.join(base, leaf)
-        return path
+            return str(grandparent / leaf)
+        return str(path_obj)
 
     @cached_property
     def install_scheme(self):

pipenv/project.py

@@ -152,7 +152,7 @@ def __init__(self, python_version=None, chdir=True):
         self._pipfile_newlines = DEFAULT_NEWLINES
         self._lockfile_newlines = DEFAULT_NEWLINES
         self._requirements_location = None
-        self._original_dir = os.path.abspath(os.curdir)
+        self._original_dir = Path.cwd().resolve()
         self._environment = None
         self._build_system = {"requires": ["setuptools", "wheel"]}
         self.python_version = python_version
@@ -692,11 +692,12 @@ def _parse_pipfile(
             return toml.loads(contents)
 
     def _read_pyproject(self) -> None:
-        pyproject = self.path_to("pyproject.toml")
-        if os.path.exists(pyproject):
-            self._pyproject = toml.load(pyproject)
+        pyproject_path = Path(self.path_to("pyproject.toml"))
+        if pyproject_path.exists():
+            self._pyproject = toml.load(pyproject_path)
             build_system = self._pyproject.get("build-system", None)
-            if not os.path.exists(self.path_to("setup.py")):
+            setup_py_path = Path(self.path_to("setup.py"))
+            if not setup_py_path.exists():
                 if not build_system or not build_system.get("requires"):
                     build_system = {
                         "requires": ["setuptools>=40.8.0", "wheel"],
@@ -783,7 +784,7 @@ def lockfile_location(self):
 
     @property
     def lockfile_exists(self):
-        return os.path.isfile(self.lockfile_location)
+        return Path(self.lockfile_location).is_file()
 
     @property
     def lockfile_content(self):
@@ -987,9 +988,7 @@ def pipfile_sources(self, expand_vars=True):
             if os.environ.get("PIPENV_PYPI_MIRROR"):
                 sources[0]["url"] = os.environ["PIPENV_PYPI_MIRROR"]
             return sources
-        # We need to make copies of the source info so we don't
-        # accidentally modify the cache. See #2100 where values are
-        # written after the os.path.expandvars() call.
+        # Expand environment variables in the source URLs.
         sources = [
             {k: safe_expandvars(v) if expand_vars else v for k, v in source.items()}
             for source in self.parsed_pipfile["source"]
@@ -1320,25 +1319,34 @@ def recase_pipfile(self):
 
     def load_lockfile(self, expand_env_vars=True):
         lockfile_modified = False
-        with open(self.lockfile_location, encoding="utf-8") as lock:
-            try:
-                j = json.load(lock)
-                self._lockfile_newlines = preferred_newlines(lock)
-            except JSONDecodeError:
-                err.print(
-                    "[bold yellow]Pipfile.lock is corrupted; ignoring contents.[/bold yellow]"
-                )
-                j = {}
+        lockfile_path = Path(self.lockfile_location)
+        pipfile_path = Path(self.pipfile_location)
+
+        try:
+            with lockfile_path.open(encoding="utf-8") as lock:
+                try:
+                    j = json.load(lock)
+                    self._lockfile_newlines = preferred_newlines(lock)
+                except JSONDecodeError:
+                    err.print(
+                        "[bold yellow]Pipfile.lock is corrupted; ignoring contents.[/bold yellow]"
+                    )
+                    j = {}
+        except FileNotFoundError:
+            j = {}
+
         if not j.get("_meta"):
-            with open(self.pipfile_location) as pf:
+            with pipfile_path.open() as pf:
                 default_lockfile = plette.Lockfile.with_meta_from(
                     plette.Pipfile.load(pf), categories=[]
                 )
                 j["_meta"] = default_lockfile._data["_meta"]
                 lockfile_modified = True
+
         if j.get("default") is None:
             j["default"] = {}
             lockfile_modified = True
+
         if j.get("develop") is None:
             j["develop"] = {}
             lockfile_modified = True
@@ -1349,14 +1357,16 @@ def load_lockfile(self, expand_env_vars=True):
         if expand_env_vars:
             # Expand environment variables in Pipfile.lock at runtime.
             for i, _ in enumerate(j["_meta"].get("sources", {})):
+                # Path doesn't have expandvars method, so we need to use os.path.expandvars
                 j["_meta"]["sources"][i]["url"] = os.path.expandvars(
                     j["_meta"]["sources"][i]["url"]
                 )
 
         return j
 
     def get_lockfile_hash(self):
-        if not os.path.exists(self.lockfile_location):
+        lockfile_path = Path(self.lockfile_location)
+        if not lockfile_path.exists():
             return
 
         try:
@@ -1443,22 +1453,35 @@ def _which(self, command, location=None, allow_global=False):
                 location = self.virtualenv_location
             else:
                 location = os.environ.get("VIRTUAL_ENV", None)
-        if not (location and Path(location).exists()) and not allow_global:
+
+        location_path = Path(location) if location else None
+
+        if not (location_path and location_path.exists()) and not allow_global:
             raise RuntimeError("location not created nor specified")
 
-        version_str = "python{}".format(".".join([str(v) for v in sys.version_info[:2]]))
-        is_python = command in ("python", os.path.basename(sys.executable), version_str)
+        version_str = f"python{'.'.join([str(v) for v in sys.version_info[:2]])}"
+        is_python = command in ("python", Path(sys.executable).name, version_str)
+
         if not allow_global:
             if os.name == "nt":
-                p = find_windows_executable(os.path.join(location, "Scripts"), command)
+                p = find_windows_executable(str(location_path / "Scripts"), command)
+                # Convert to Path object if it's a string
+                p = Path(p) if isinstance(p, str) else p
             else:
-                p = Path(location) / "bin" / command
+                p = location_path / "bin" / command
         elif is_python:
             p = Path(sys.executable)
-        p_str = str(p) if isinstance(p, Path) else p
-        if not os.path.exists(p_str):
+        else:
+            p = None
+
+        if p is None or not p.exists():
             if is_python:
-                p = sys.executable or system_which("python")
+                p = (
+                    Path(sys.executable)
+                    if sys.executable
+                    else Path(system_which("python"))
+                )
             else:
-                p = system_which(command)
+                p = Path(system_which(command)) if system_which(command) else None
+
         return p

pipenv/routines/shell.py

@@ -60,6 +60,8 @@ def do_run(project, command, args, python=False, pypi_mirror=None):
 
     Args are appended to the command in [scripts] section of project if found.
     """
+    from pathlib import Path
+
     from pipenv.cmdparse import ScriptEmptyError
 
     env = os.environ.copy()
@@ -74,14 +76,13 @@ def do_run(project, command, args, python=False, pypi_mirror=None):
 
     path = env.get("PATH", "")
     if project.virtualenv_location:
-        new_path = os.path.join(
-            project.virtualenv_location, "Scripts" if os.name == "nt" else "bin"
-        )
-        paths = path.split(os.pathsep)
-        paths.insert(0, new_path)
-        path = os.pathsep.join(paths)
-        env["VIRTUAL_ENV"] = project.virtualenv_location
-    env["PATH"] = path
+        virtualenv_path = Path(project.virtualenv_location)
+        bin_dir = "Scripts" if os.name == "nt" else "bin"
+        new_path = str(virtualenv_path / bin_dir)
+        env["PATH"] = f"{new_path}{os.pathsep}{path}"
+        env["VIRTUAL_ENV"] = str(virtualenv_path)
+    else:
+        env["PATH"] = str(path)
 
     # Set an environment variable, so we know we're in the environment.
     # Only set PIPENV_ACTIVE after finishing reading virtualenv_location
@@ -135,7 +136,7 @@ def do_run_posix(project, script, command, env):
         sys.exit(1)
     os.execve(
         command_path,
-        [command_path, *(os.path.expandvars(arg) for arg in script.args)],
+        [command_path, *(expandvars(arg) for arg in script.args)],
         env,
     )
 

pipenv/shells.py

@@ -15,7 +15,8 @@
 
 
 def _build_info(value):
-    return (os.path.splitext(os.path.basename(value))[0], value)
+    path = Path(value)
+    return (path.stem, value)
 
 
 def detect_info(project):
@@ -86,25 +87,25 @@ def __repr__(self):
 
     @contextlib.contextmanager
     def inject_path(self, venv):
+        venv_path = Path(venv)
         with temp_environ():
-            os.environ["PATH"] = "{}{}{}".format(
-                os.pathsep.join(str(p.parent) for p in _iter_python(venv)),
-                os.pathsep,
-                os.environ["PATH"],
+            os.environ["PATH"] = (
+                f"{os.pathsep.join(str(p.parent) for p in _iter_python(venv_path))}{os.pathsep}{os.environ['PATH']}"
             )
             yield
 
     def fork(self, venv, cwd, args):
         # FIXME: This isn't necessarily the correct prompt. We should read the
         # actual prompt by peeking into the activation script.
-        name = os.path.basename(venv)
-        os.environ["VIRTUAL_ENV"] = str(venv)
+        venv_path = Path(venv)
+        name = venv_path.name
+        os.environ["VIRTUAL_ENV"] = str(venv_path)
         if "PROMPT" in os.environ:
-            os.environ["PROMPT"] = "({}) {}".format(name, os.environ["PROMPT"])
+            os.environ["PROMPT"] = f"({name}) {os.environ['PROMPT']}"
         if "PS1" in os.environ:
-            os.environ["PS1"] = "({}) {}".format(name, os.environ["PS1"])
+            os.environ["PS1"] = f"({name}) {os.environ['PS1']}"
         with self.inject_path(venv):
-            os.chdir(cwd)
+            os.chdir(str(cwd) if isinstance(cwd, Path) else cwd)
             _handover(self.cmd, self.args + list(args))
 
     def fork_compat(self, venv, cwd, args):
@@ -187,16 +188,16 @@ def fork(self, venv, cwd, args):
 
 class CmderCommandPrompt(CmderEmulatedShell):
     def fork(self, venv, cwd, args):
-        rc = os.path.expandvars("%CMDER_ROOT%\\vendor\\init.bat")
-        if os.path.exists(rc):
-            self.args.extend(["/k", rc])
+        rc_path = Path(os.path.expandvars("%CMDER_ROOT%\\vendor\\init.bat"))
+        if rc_path.exists():
+            self.args.extend(["/k", str(rc_path)])
         super().fork(venv, cwd, args)
 
 
 class CmderPowershell(Shell):
     def fork(self, venv, cwd, args):
-        rc = os.path.expandvars("%CMDER_ROOT%\\vendor\\profile.ps1")
-        if os.path.exists(rc):
+        rc_path = Path(os.path.expandvars("%CMDER_ROOT%\\vendor\\profile.ps1"))
+        if rc_path.exists():
             self.args.extend(
                 [
                     "-ExecutionPolicy",
@@ -205,7 +206,7 @@ def fork(self, venv, cwd, args):
                     "-NoProfile",
                     "-NoExit",
                     "-Command",
-                    f"Invoke-Expression '. ''{rc}'''",
+                    f"Invoke-Expression '. ''{rc_path}'''",
                 ]
             )
         super().fork(venv, cwd, args)