App basically works

Need to fix some typing errors still.

Author: chriskuehl

poetry.lock

@@ -1,14 +1,22 @@
+import mimetypes
 import os.path
 
 from starlette.applications import Starlette
 from starlette.staticfiles import StaticFiles
 from starlette.requests import Request
+from starlette.responses import Response
 from starlette.responses import PlainTextResponse
+from starlette.responses import StreamingResponse
 from starlette.routing import Route
 from starlette.templating import Jinja2Templates
 
+from pypi_view import packaging
 from pypi_view import pypi
 
+PACKAGE_TYPE_NOT_SUPPORTED_ERROR = (
+    "Sorry, this package type is not yet supported (only .zip and .whl supported currently)."
+)
+
 
 install_root = os.path.dirname(__file__)
 
@@ -21,37 +29,112 @@
 
 
 @app.route('/')
-async def home(request: Request) -> templates.TemplateResponse:
+async def home(request: Request) -> Response:
     return templates.TemplateResponse("home.html", {"request": request})
 
 
 @app.route('/package/{package}')
-async def package(request: Request) -> templates.TemplateResponse:
-    package = request.path_params["package"]
-    version_to_files = await pypi.files_for_package(package)
+async def package(request: Request) -> Response:
+    package_name  = request.path_params["package"]
+    try:
+        version_to_files = await pypi.files_for_package(package_name)
+    except pypi.PackageDoesNotExist:
+        return PlainTextResponse(
+            f"Package {package_name!r} does not exist on PyPI.",
+            status_code=404,
+        )
+    else:
+        return templates.TemplateResponse(
+            "package.html",
+            {
+                "request": request,
+                "package": package_name,
+                "version_to_files": version_to_files,
+            },
+        )
+
+
+@app.route('/package/{package}/{filename}')
+async def package_file(request: Request) -> Response:
+    package_name = request.path_params["package"]
+    file_name = request.path_params["filename"]
+    try:
+        archive = await pypi.downloaded_file_path(package_name, file_name)
+    except pypi.PackageDoesNotExist:
+        return PlainTextResponse(
+            f"Package {package_name!r} does not exist on PyPI.",
+            status_code=404,
+        )
+    except pypi.CannotFindFileError:
+        return PlainTextResponse(
+            f"File {file_name!r} does not exist for package {package_name!r}.",
+            status_code=404,
+        )
+
+    try:
+        package = packaging.Package.from_path(archive)
+    except packaging.UnsupportedPackageType:
+        return PlainTextResponse(
+            PACKAGE_TYPE_NOT_SUPPORTED_ERROR,
+            status_code=501,
+        )
+
+    entries = await package.entries()
     return templates.TemplateResponse(
-        "package.html",
+        "package_file.html",
         {
             "request": request,
-            "package": package,
-            "version_to_files": version_to_files,
+            "package": package_name,
+            "filename": file_name,
+            "entries": entries,
         },
     )
 
 
-@app.route('/package/{package}/{filename}')
-async def package_file(request: Request) -> templates.TemplateResponse:
-    package = request.path_params["package"]
-    filename = request.path_params["filename"]
-    archive = await pypi.downloaded_file_path(package, filename)
-    return PlainTextResponse(
-        f"Path: {archive} Size: {os.stat(archive)}",
-    )
+@app.route('/package/{package}/{filename}/{archive_path:path}')
+async def package_file_archive_path(request: Request) -> Response:
+    package_name = request.path_params["package"]
+    file_name = request.path_params["filename"]
+    archive_path = request.path_params["archive_path"]
+    try:
+        archive = await pypi.downloaded_file_path(package_name, file_name)
+    except pypi.PackageDoesNotExist:
+        return PlainTextResponse(
+            f"Package {package_name!r} does not exist on PyPI.",
+            status_code=404,
+        )
+    except pypi.CannotFindFileError:
+        return PlainTextResponse(
+            f"File {file_name!r} does not exist for package {package_name!r}.",
+            status_code=404,
+        )
+    try:
+        package = packaging.Package.from_path(archive)
+    except packaging.UnsupportedPackageType:
+        return PlainTextResponse(
+            PACKAGE_TYPE_NOT_SUPPORTED_ERROR,
+            status_code=501,
+        )
 
+    entries = await package.entries()
+    matching_entries = [entry for entry in entries if entry.path == archive_path]
+    if len(matching_entries) == 0:
+        return PlainTextResponse(
+            f"Path {archive_path!r} does not exist in archive.",
+            status_code=404,
+        )
+    entry = matching_entries[0]
 
-@app.route('/package/{package}/{filename}/{archive_path:path}')
-async def package_file_archive_path(request: Request) -> templates.TemplateResponse:
-    print(request.path_params["package"])
-    print(request.path_params["filename"])
-    print(request.path_params["archive_path"])
-    raise NotImplementedError()
+    async def transfer_file():
+        async with package.open_from_archive(archive_path) as f:
+            data = None
+            while data is None or len(data) > 0:
+                data = await f.read(1024)
+                yield data
+
+    mimetype, _ = mimetypes.guess_type(archive_path)
+    return StreamingResponse(
+        transfer_file(),
+        media_type=mimetype or "text/plain",
+        headers={"Content-Length": str(entry.size)},
+    )

pypi_view/app.py

@@ -0,0 +1,107 @@
+import asyncio
+import base64
+import contextlib
+import enum
+import os.path
+import typing
+import zipfile
+from dataclasses import dataclass
+
+
+class UnsupportedPackageType(Exception):
+    pass
+
+
+class PackageType(enum.Enum):
+    SDIST = enum.auto()
+    WHEEL = enum.auto()
+
+
+class PackageFormat(enum.Enum):
+    ZIPFILE = enum.auto()
+    TARBALL = enum.auto()
+    TARBALL_GZ = enum.auto()
+    TARBALL_BZ2 = enum.auto()
+
+
+@dataclass(frozen=True)
+class PackageEntry:
+    path: str
+    size: int
+
+
+def _package_entries_from_zipfile(path: str) -> typing.Set[PackageEntry]:
+    with zipfile.ZipFile(path) as zf:
+        return {
+            PackageEntry(
+                path=entry.filename,
+                size=entry.file_size,
+            )
+            for entry in zf.infolist()
+        }
+
+
+ArchiveFile = typing.Union[zipfile.ZipExtFile]
+
+
+class AsyncArchiveFile:
+
+    file_: ArchiveFile
+
+    def __init__(self, file_: ArchiveFile) -> None:
+        self.file_ = file_
+
+    async def __aenter__(self) -> "AsyncArchiveFile":
+        return self
+
+    async def __aexit__(self, exc_t, exc_v, exc_tb) -> None:
+        await asyncio.to_thread(self.file_.close)
+
+    async def read(self, n_bytes: typing.Optional[int]) -> bytes:
+        return await asyncio.to_thread(self.file_.read, n_bytes)
+
+
+@dataclass(frozen=True)
+class Package:
+    package_type: PackageType
+    package_format: PackageFormat
+    path: str
+
+    @classmethod
+    def from_path(cls, path: str) -> "Package":
+        name = base64.b64decode(os.path.basename(path).encode("ascii")).decode("utf8")
+
+        if name.endswith(".whl"):
+            package_type = PackageType.WHEEL
+            package_format = PackageFormat.ZIPFILE
+        elif name.endswith(".zip"):
+            package_type = PackageType.SDIST
+            package_format = PackageFormat.ZIPFILE
+        else:
+            # TODO: Add support for tarballs
+            raise UnsupportedPackageType(name)
+
+        return cls(
+            package_type=package_type,
+            package_format=package_format,
+            path=path,
+        )
+
+    async def entries(self) -> typing.Set[PackageEntry]:
+        if self.package_format is PackageFormat.ZIPFILE:
+            return await asyncio.to_thread(_package_entries_from_zipfile, self.path)
+        else:
+            raise AssertionError(self.package_format)
+
+    @contextlib.asynccontextmanager
+    async def open_from_archive(self, path: str) -> str:
+        if self.package_format is PackageFormat.ZIPFILE:
+            zf = await asyncio.to_thread(zipfile.ZipFile, self.path)
+            archive_file = await asyncio.to_thread(zf.open, path)
+            try:
+                async with AsyncArchiveFile(archive_file) as zip_archive_file:
+                    yield zip_archive_file
+            finally:
+                await asyncio.to_thread(zf.close)
+        else:
+            raise AssertionError(self.package_format)

pypi_view/packaging.py

@@ -5,6 +5,7 @@
 import typing
 
 import aiofiles
+import aiofiles.os
 import httpx
 
 
@@ -13,8 +14,14 @@
 STORAGE_DIR = '/home/ckuehl/tmp/pypi-view'
 
 
+class PackageDoesNotExist(Exception):
+    pass
+
+
 async def package_metadata(client: httpx.AsyncClient, package: str) -> typing.Dict:
     resp = await client.get(f'{PYPI}/pypi/{package}/json')
+    if resp.status_code == 404:
+        raise PackageDoesNotExist(package)
     resp.raise_for_status()
     return resp.json()
 
@@ -48,11 +55,11 @@ async def _atomic_file(path: str, mode: str = 'w') -> typing.Any:
         try:
             yield f
         except:
-            os.remove(f.name)
+            await aiofiles.os.remove(f.name)
             raise
         else:
             # This is atomic since the temporary file was created in the same directory.
-            os.rename(f.name, path)
+            await aiofiles.os.rename(f.name, path)
 
 
 async def downloaded_file_path(package: str, filename: str) -> str:
@@ -62,7 +69,7 @@ async def downloaded_file_path(package: str, filename: str) -> str:
     it and may take a while.
     """
     stored_path = _storage_path(package, filename)
-    if os.path.exists(stored_path):
+    if await aiofiles.os.path.exists(stored_path):
         return stored_path
 
     async with httpx.AsyncClient() as client:
@@ -78,7 +85,7 @@ async def downloaded_file_path(package: str, filename: str) -> str:
         else:
             raise CannotFindFileError(package, filename)
 
-        os.makedirs(os.path.dirname(stored_path), exist_ok=True)
+        await aiofiles.os.makedirs(os.path.dirname(stored_path), exist_ok=True)
 
         async with _atomic_file(stored_path, 'wb') as f:
             async with client.stream('GET', url) as resp:

pypi_view/pypi.py

@@ -0,0 +1,19 @@
+{% set page = 'package-file' %}
+{% extends 'base.html' %}
+
+{% block content %}
+    <h1>{{filename}}</h1>
+    <ul>
+        {% for entry in entries|sort(attribute="path") %}
+            <li>
+                <a
+                    href="{{url_for('package_file_archive_path', package=package, filename=filename, archive_path=entry.path)}}"
+                >{{entry.path}}</a>
+                ({{entry.size}} bytes)
+            </li>
+        {% endfor %}
+    </ul>
+{% endblock %}
+
+{# vim: ft=jinja
+#}

pypi_view/templates/package_file.html

@@ -8,7 +8,7 @@ readme = "README.md"
 packages = [{include = "pypi_view"}]
 
 [tool.poetry.dependencies]
-python = "^3.8"
+python = "^3.9"
 starlette = "*"
 fluffy-code = "^0.0.0"
 Jinja2 = "^3.1.2"
@@ -22,6 +22,7 @@ pre-commit = "^2.20.0"
 pytest = "^7.1.3"
 mypy = "^0.971"
 coverage = "^6.4.4"
+types-aiofiles = "^22.1.0"
 
 [build-system]
 requires = ["poetry-core"]