stop using requirementslib models

pipenv/environment.py

@@ -11,14 +11,17 @@
 import typing
 from pathlib import Path
 from sysconfig import get_paths, get_python_version, get_scheme_names
-from urllib.parse import urlparse
-from urllib.request import url2pathname
+from urllib.parse import unquote, urlparse
 
 import pipenv
 from pipenv.patched.pip._internal.commands.install import InstallCommand
 from pipenv.patched.pip._internal.index.package_finder import PackageFinder
+from pipenv.patched.pip._internal.req.req_install import InstallRequirement
+from pipenv.patched.pip._internal.vcs.versioncontrol import VersionControl
 from pipenv.patched.pip._vendor import pkg_resources
+from pipenv.patched.pip._vendor.packaging.specifiers import SpecifierSet
 from pipenv.patched.pip._vendor.packaging.utils import canonicalize_name
+from pipenv.utils.dependencies import as_pipfile
 from pipenv.utils.funktools import chunked, unnest
 from pipenv.utils.indexes import prepare_pip_source_args
 from pipenv.utils.processes import subprocess_run
@@ -200,11 +203,6 @@ def base_paths(self) -> dict[str, str]:
         .. note:: The implementation of this is borrowed from a combination of pip and
            virtualenv and is likely to change at some point in the future.
 
-        >>> from pipenv.core import project
-        >>> from pipenv.environment import Environment
-        >>> env = Environment(prefix=project.virtualenv_location, is_venv=True, sources=project.sources)
-        >>> import pprint
-        >>> pprint.pprint(env.base_paths)
         {'PATH': '/home/hawk/.virtualenvs/pipenv-MfOPs1lW/bin::/bin:/usr/bin',
         'PYTHONPATH': '/home/hawk/.virtualenvs/pipenv-MfOPs1lW/lib/python3.7/site-packages',
         'data': '/home/hawk/.virtualenvs/pipenv-MfOPs1lW',
@@ -760,38 +758,43 @@ def is_installed(self, pkgname):
 
         return any(d for d in self.get_distributions() if d.project_name == pkgname)
 
-    def is_satisfied(self, req):
+    def is_satisfied(self, req: InstallRequirement):
         match = next(
             iter(
                 d
                 for d in self.get_distributions()
-                if canonicalize_name(d.project_name) == req.normalized_name
+                if req.name
+                and canonicalize_name(d.project_name) == canonicalize_name(req.name)
             ),
             None,
         )
         if match is not None:
-            if req.editable and req.line_instance.is_local and self.find_egg(match):
-                requested_path = req.line_instance.path
+            if req.editable and req.link and req.link.is_file:
+                requested_path = req.link.file_path
                 if os.path.exists(requested_path):
                     local_path = requested_path
                 else:
                     parsed_url = urlparse(requested_path)
-                    local_path = url2pathname(parsed_url.path)
+                    local_path = parsed_url.path
                 return requested_path and os.path.samefile(local_path, match.location)
             elif match.has_metadata("direct_url.json"):
                 direct_url_metadata = json.loads(match.get_metadata("direct_url.json"))
                 commit_id = direct_url_metadata.get("vcs_info", {}).get("commit_id", "")
                 vcs_type = direct_url_metadata.get("vcs_info", {}).get("vcs", "")
-                _, pipfile_part = req.as_pipfile().popitem()
+                _, pipfile_part = as_pipfile(req).popitem()
+                vcs_backend = VersionControl.get_backend_for_scheme(req.link.scheme)
+                req_commit = (
+                    unquote(vcs_backend().get_revision(req.link)) if vcs_backend else None
+                )
                 return (
-                    vcs_type == req.vcs
-                    and commit_id == req.commit_hash
-                    and direct_url_metadata["url"] == pipfile_part[req.vcs]
+                    vcs_type == req.link.scheme
+                    and commit_id == req_commit
+                    and direct_url_metadata["url"] == pipfile_part[req.link.scheme]
                 )
-            elif req.is_vcs or req.is_file_or_url:
+            elif req.link and req.link.is_vcs:
                 return False
-            elif req.line_instance.specifiers is not None:
-                return req.line_instance.specifiers.contains(
+            elif req.specifier is not None:
+                return SpecifierSet(str(req.specifier)).contains(
                     match.version, prereleases=True
                 )
             return True

pipenv/patched/pip/_internal/req/constructors.py

@@ -39,7 +39,9 @@
 operators = Specifier._operators.keys()
 
 
-def _strip_extras(path: str) -> Tuple[str, Optional[str]]:
+def _strip_extras(path: str) -> Tuple[Optional[str], Optional[str]]:
+    if path is None:
+        return None, None
     m = re.match(r"^(.+)(\[[^\]]+\])$", path)
     extras = None
     if m:
@@ -305,6 +307,7 @@ def parse_req_from_line(name: str, line_source: Optional[str]) -> RequirementPar
 
     if is_url(name):
         link = Link(name)
+        _, extras_as_string = _strip_extras(link.egg_fragment)
     else:
         p, extras_as_string = _strip_extras(path)
         url = _get_url_from_path(p, name)

pipenv/project.py

@@ -11,6 +11,11 @@
 import urllib.parse
 from json.decoder import JSONDecodeError
 from pathlib import Path
+from tempfile import TemporaryDirectory
+from urllib.parse import unquote
+
+from pipenv.utils.constants import VCS_LIST
+from pipenv.vendor.requirementslib.models.setup_info import unpack_url
 
 try:
     import tomllib as toml
@@ -23,10 +28,16 @@
 from pipenv.patched.pip._internal.commands.install import InstallCommand
 from pipenv.patched.pip._internal.configuration import Configuration
 from pipenv.patched.pip._internal.exceptions import ConfigurationError
+from pipenv.patched.pip._internal.network.download import Downloader
+from pipenv.patched.pip._internal.req.req_install import InstallRequirement
 from pipenv.patched.pip._vendor import pkg_resources
 from pipenv.utils.constants import is_type_checking
 from pipenv.utils.dependencies import (
+    find_package_name_from_directory,
+    find_package_name_from_tarball,
+    find_package_name_from_zipfile,
     get_canonical_names,
+    install_req_from_line,
     is_editable,
     pep423_name,
     python_version,
@@ -45,7 +56,11 @@
 )
 from pipenv.utils.toml import cleanup_toml, convert_toml_outline_tables
 from pipenv.vendor import click, plette, tomlkit
-from pipenv.vendor.requirementslib.models.utils import get_default_pyproject_backend
+from pipenv.vendor.requirementslib.models.utils import (
+    get_default_pyproject_backend,
+    normalize_name,
+)
+from pipenv.vendor.requirementslib.utils import get_pip_command
 
 try:
     # this is only in Python3.8 and later
@@ -937,7 +952,9 @@ def find_source(sources, name=None, url=None):
 
     def get_package_name_in_pipfile(self, package_name, category):
         """Get the equivalent package name in pipfile"""
-        section = self.parsed_pipfile.get(category, {})
+        section = self.parsed_pipfile.get(category)
+        if section is None:
+            section = {}
         package_name = pep423_name(package_name)
         for name in section.keys():
             if pep423_name(name) == package_name:
@@ -969,30 +986,116 @@ def remove_packages_from_pipfile(self, packages):
         self.write_toml(parsed)
 
     def add_package_to_pipfile(self, package, dev=False, category=None):
-        from .vendor.requirementslib import Requirement
-
         newly_added = False
+        category = category if category else "dev-packages" if dev else "packages"
+
         # Read and append Pipfile.
         p = self.parsed_pipfile
-        # Don't re-capitalize file URLs or VCSs.
-        if not isinstance(package, Requirement):
-            package = Requirement.from_line(package.strip(), parse_setup_info=False)
-        req_name, converted = package.pipfile_entry
-        category = category if category else "dev-packages" if dev else "packages"
+
         # Set empty group if it doesn't exist yet.
         if category not in p:
             p[category] = {}
-        # Add the package to the group.
+
+        # Don't re-capitalize file URLs or VCSs.
+        if not isinstance(package, InstallRequirement):
+            package = install_req_from_line(package.strip())
+
+        path_specifier = None
+        vcs_specifier = None
+        if package.link and package.link.scheme in [
+            "http",
+            "https",
+            "file",
+            "ftp",
+            "git+http",
+            "git+https",
+            "git+ssh",
+            "git+git",
+            "hg+http",
+            "hg+https",
+            "hg+ssh",
+            "svn+http",
+            "svn+https",
+            "svn+svn",
+            "bzr+http",
+            "bzr+https",
+            "bzr+ssh",
+            "bzr+sftp",
+            "bzr+ftp",
+            "bzr+lp",
+        ]:
+            with TemporaryDirectory() as td:
+                cmd = get_pip_command()
+                options, _ = cmd.parser.parse_args([])
+                session = cmd._build_session(options)
+                file = unpack_url(
+                    link=package.link,
+                    location=td,
+                    download=Downloader(session, "off"),
+                    verbosity=1,
+                )
+                if file.path.endswith(".whl") or file.path.endswith(".zip"):
+                    req_name = find_package_name_from_zipfile(file.path)
+                elif file.path.endswith(".tar.gz") or file.path.endswith(".tar.bz2"):
+                    req_name = find_package_name_from_tarball(file.path)
+                else:
+                    req_name = find_package_name_from_directory(file.path)
+                if package.link.scheme == "file":
+                    path_specifier = package.link.url
+                else:
+                    vcs_specifier = package.link.url_without_fragment
+        elif package.link and package.link.scheme == "file":
+            if package.link.file_path.endswith(".whl"):
+                req_name = find_package_name_from_zipfile(package.link.file_path)
+            elif package.link.file_path.endswith(".tar.gz"):
+                req_name = find_package_name_from_tarball(package.link.file_path)
+            else:
+                req_name = find_package_name_from_directory(package.link.file_path)
+            path_specifier = os.path.relpath(
+                package.link.file_path
+            )  # Preserve the original file path
+        elif package.name:
+            req_name = package.name
+        else:
+            raise ValueError(f"Could not determine package name from {package}")
+
         name = self.get_package_name_in_pipfile(req_name, category=category)
         normalized_name = pep423_name(req_name)
         if name and name != normalized_name:
             self.remove_package_from_pipfile(name, category=category)
+
+        extras = package.extras
+        specifier = "*"
+        if package.req and package.specifier:
+            specifier = str(package.specifier)
+
+        # Add the package to the group.
+        normalized_name = normalize_name(req_name)
         if normalized_name not in p[category]:
             newly_added = True
-        p[category][normalized_name] = converted
+
+        # Construct package requirement
+        converted = {}
+        if extras:
+            converted["extras"] = list(extras)
+        if path_specifier:
+            converted["file"] = unquote(path_specifier)
+        elif vcs_specifier:
+            for vcs in VCS_LIST:
+                if vcs in package.link.scheme:
+                    converted[vcs] = unquote(vcs_specifier)
+                    break
+        else:
+            converted["version"] = specifier
+
+        if len(converted) == 1 and "version" in converted:
+            p[category][normalized_name] = specifier
+        else:
+            p[category][normalized_name] = converted
+
         # Write Pipfile.
         self.write_toml(p)
-        return newly_added, category
+        return newly_added, category, normalized_name
 
     def src_name_from_url(self, index_url):
         name, _, tld_guess = urllib.parse.urlsplit(index_url).netloc.rpartition(".")