tmp

Author: jobselko

pulp_python/app/pypi/views.py

@@ -277,17 +277,17 @@ def list(self, request, path):
             return redirect(urljoin(self.base_content_url, f"{path}/simple/"))
         names = content.order_by("name").values_list("name", flat=True).distinct().iterator()
         media_type = request.accepted_renderer.media_type
+        headers = {"X-PyPI-Last-Serial": str(PYPI_SERIAL_CONSTANT)}
 
         if media_type == PYPI_SIMPLE_V1_JSON:
             index_data = write_simple_index_json(names)
-            headers = {"X-PyPI-Last-Serial": str(PYPI_SERIAL_CONSTANT)}
             return Response(index_data, headers=headers)
         else:
             index_data = write_simple_index(names, streamed=True)
-            kwargs = {"content_type": media_type}
+            kwargs = {"content_type": media_type, "headers": headers}
             return StreamingHttpResponse(index_data, **kwargs)
 
-    def pull_through_package_simple(self, package, path, remote):
+    def pull_through_package_simple(self, package, path, remote, media_type):
         """Gets the package's simple page from remote."""
 
         def parse_package(release_package):
@@ -299,7 +299,8 @@ def parse_package(release_package):
                 "filename": release_package.filename,
                 "url": d_url,
                 "sha256": release_package.digests.get("sha256", ""),
-                # todo: more fields?
+                "requires_python": release_package.requires_python,
+                "metadata_sha256": (release_package.metadata_digests or {}).get("sha256", ""),
             }
 
         rfilter = get_remote_package_filter(remote)
@@ -324,27 +325,33 @@ def parse_package(release_package):
         packages = [
             parse_package(p) for p in page.packages if rfilter.filter_release(package, p.version)
         ]
-        return HttpResponse(write_simple_detail(package, packages))
+        headers = {"X-PyPI-Last-Serial": str(PYPI_SERIAL_CONSTANT)}
+
+        if media_type == PYPI_SIMPLE_V1_JSON:
+            detail_data = write_simple_detail_json(package, packages)
+            return Response(detail_data, headers=headers)
+        else:
+            detail_data = write_simple_detail(package, packages)
+            kwargs = {"content_type": media_type, "headers": headers}
+            return HttpResponse(detail_data, **kwargs)
 
     @extend_schema(operation_id="pypi_simple_package_read", summary="Get package simple page")
     def retrieve(self, request, path, package):
-        """Retrieves the simple api html page for a package."""
+        """Retrieves the simple api html/json page for a package."""
+        media_type = request.accepted_renderer.media_type
+
         repo_ver, content = self.get_rvc()
         # Should I redirect if the normalized name is different?
         normalized = canonicalize_name(package)
         if self.distribution.remote:
-            return self.pull_through_package_simple(normalized, path, self.distribution.remote)
+            return self.pull_through_package_simple(
+                normalized, path, self.distribution.remote, media_type
+            )
         if self.should_redirect(repo_version=repo_ver):
             return redirect(urljoin(self.base_content_url, f"{path}/simple/{normalized}/"))
         packages = (
             content.filter(name__normalize=normalized)
-            .values_list(
-                "filename",
-                "sha256",
-                "name",
-                "metadata_sha256",
-                "requires_python",
-            )
+            .values_list("filename", "sha256", "name", "metadata_sha256", "requires_python")
             .iterator()
         )
         try:
@@ -365,15 +372,15 @@ def retrieve(self, request, path, package):
             for f, s, _, ms, rp in packages
         )
         media_type = request.accepted_renderer.media_type
+        headers = {"X-PyPI-Last-Serial": str(PYPI_SERIAL_CONSTANT)}
 
         if media_type == PYPI_SIMPLE_V1_JSON:
             detail_data = write_simple_detail_json(name, releases)
-            headers = {"X-PyPI-Last-Serial": str(PYPI_SERIAL_CONSTANT)}
             return Response(detail_data, headers=headers)
         else:
             detail_data = write_simple_detail(name, releases, streamed=True)
-            kwargs = {"content_type": media_type}
-            return StreamingHttpResponse(detail_data, kwargs)
+            kwargs = {"content_type": media_type, "headers": headers}
+            return StreamingHttpResponse(detail_data, **kwargs)
 
     @extend_schema(
         request=PackageUploadSerializer,

pulp_python/app/utils.py

@@ -22,7 +22,7 @@
 <html>
   <head>
     <title>Simple Index</title>
-    <meta name="pypi:repository-version" content="{SIMPLE_API_VERSION}">
+    <meta name="pypi:repository-version" content="{{ SIMPLE_API_VERSION }}">
   </head>
   <body>
     {% for name, canonical_name in projects %}
@@ -36,7 +36,7 @@
 <html>
 <head>
   <title>Links for {{ project_name }}</title>
-  <meta name="api-version" value="2" />
+    <meta name="pypi:repository-version" content="{{ SIMPLE_API_VERSION }}">
 </head>
 <body>
     <h1>Links for {{ project_name }}</h1>
@@ -409,14 +409,21 @@ def find_artifact():
 def write_simple_index(project_names, streamed=False):
     """Writes the simple index."""
     simple = Template(simple_index_template)
-    context = {"projects": ((x, canonicalize_name(x)) for x in project_names)}
+    context = {
+        "SIMPLE_API_VERSION": SIMPLE_API_VERSION,
+        "projects": ((x, canonicalize_name(x)) for x in project_names),
+    }
     return simple.stream(**context) if streamed else simple.render(**context)
 
 
 def write_simple_detail(project_name, project_packages, streamed=False):
     """Writes the simple detail page of a package."""
     detail = Template(simple_detail_template)
-    context = {"project_name": project_name, "project_packages": project_packages}
+    context = {
+        "SIMPLE_API_VERSION": SIMPLE_API_VERSION,
+        "project_name": project_name,
+        "project_packages": project_packages,
+    }
     return detail.stream(**context) if streamed else detail.render(**context)
 
 

pulp_python/tests/functional/api/test_domains.py

@@ -265,18 +265,28 @@ def test_domain_pypi_apis(
     assert response["projects"] == response["releases"] == response["files"] == 1
 
     # Test download
-    subprocess.run(
-        (
-            "pip",
-            "install",
-            "--no-deps",
-            "--no-build-isolation",
-            "--trusted-host",
-            urlsplit(distro.base_url).hostname,
-            "-i",
-            distro.base_url + "simple/",
-            "shelf-reader",
-        ),
-        capture_output=True,
-        check=True,
-    )
+    try:
+        subprocess.run(
+            (
+                "pip",
+                "install",
+                "--no-deps",
+                "--no-build-isolation",
+                "--trusted-host",
+                urlsplit(distro.base_url).hostname,
+                "-i",
+                distro.base_url + "simple/",
+                "shelf-reader",
+            ),
+            capture_output=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(f"Pip install failed with return code {e.returncode}")
+        print(f"STDOUT: {e.stdout.decode() if e.stdout else 'None'}")
+        print(f"STDERR: {e.stderr.decode() if e.stderr else 'None'}")
+        raise
+    except Exception as e:
+        print(f"Unexpected error during pip install: {e}")
+        print(f"Exception type: {type(e)}")
+        raise

pulp_python/tests/functional/api/test_full_mirror.py

@@ -58,6 +58,24 @@ def test_pull_through_simple(python_remote_factory, python_distribution_factory,
         assert PYTHON_XS_FIXTURE_CHECKSUMS[package.filename] == package.digests["sha256"]
 
 
+@pytest.mark.parallel
+@pytest.mark.parametrize("media_type", ["application/vnd.pypi.simple.v1+json", "text/html"])
+def test_pull_through_simple_media_types(
+    media_type, python_remote_factory, python_distribution_factory
+):
+    """Tests pull-through with different media types (JSON and HTML)."""
+    remote = python_remote_factory(url=PYPI_URL, includes=["shelf-reader"])
+    distro = python_distribution_factory(remote=remote.pulp_href)
+
+    url = f"{distro.base_url}simple/shelf-reader/"
+    headers = {"Accept": media_type}
+    response = requests.get(url, headers=headers)
+
+    assert response.status_code == 200
+    assert media_type in response.headers["Content-Type"]
+    assert "X-PyPI-Last-Serial" in response.headers
+
+
 @pytest.mark.parallel
 def test_pull_through_filter(python_remote_factory, python_distribution_factory):
     """Tests that pull-through respects the includes/excludes filter on the remote."""