Generate the static file hashes at app startup, rather than requiring a build stage.

Author: pelson

README.md

@@ -79,4 +79,3 @@ The browser can be run with:
 ```bash
 python -m simple_repository_browser
 ```
-

setup.py

@@ -42,7 +42,7 @@ def handler(args: typing.Any) -> None:
             # Include the "base" folder, such that upstream templates can inherit from "base/...".
             here/"templates",
         ],
-        static_files_path=here / "static",
+        static_files_paths=[here / "static_source"],
         crawl_popular_projects=args.crawl_popular_projects,
         url_prefix=args.url_prefix,
         browser_version=__version__,

simple_repository_browser/__main__.py

@@ -15,6 +15,7 @@
 
 from . import controller, crawler, errors, fetch_projects, model, view
 from .metadata_injector import MetadataInjector
+from .static_files import generate_manifest
 
 
 class AppBuilder:
@@ -24,15 +25,15 @@ def __init__(
         repository_url: str,
         cache_dir: Path,
         template_paths: typing.Sequence[Path],
-        static_files_path: Path,
+        static_files_paths: typing.Sequence[Path],
         crawl_popular_projects: bool,
         browser_version: str,
     ) -> None:
         self.url_prefix = url_prefix
         self.repository_url = repository_url
         self.cache_dir = cache_dir
         self.template_paths = template_paths
-        self.static_files_path = static_files_path
+        self.static_files_manifest = generate_manifest(static_files_paths)
         self.crawl_popular_projects = crawl_popular_projects
         self.browser_version = browser_version
 
@@ -50,6 +51,7 @@ def create_app(self) -> fastapi.FastAPI:
         _view = self.create_view()
 
         async def lifespan(app: fastapi.FastAPI):
+
             async with (
                 httpx.AsyncClient(timeout=30) as http_client,
                 aiosqlite.connect(self.db_path, timeout=5) as db,
@@ -61,7 +63,7 @@ async def lifespan(app: fastapi.FastAPI):
                     ),
                     view=_view,
                 )
-                router = _controller.create_router(self.static_files_path)
+                router = _controller.create_router(self.static_files_manifest)
                 app.mount(self.url_prefix or "/", router)
 
                 if self.url_prefix:
@@ -107,7 +109,7 @@ async def catch_exceptions_middleware(request: fastapi.Request, call_next):
         return app
 
     def create_view(self) -> view.View:
-        return view.View(self.template_paths, self.browser_version, static_files_path=self.static_files_path)
+        return view.View(self.template_paths, self.browser_version, static_files_manifest=self.static_files_manifest)
 
     def create_crawler(self, http_client: httpx.AsyncClient, source: SimpleRepository) -> crawler.Crawler:
         return crawler.Crawler(

simple_repository_browser/_app.py

@@ -2,16 +2,15 @@
 import dataclasses
 from enum import Enum
 from functools import partial
-from pathlib import Path
 import typing
 
 import fastapi
 from fastapi.responses import StreamingResponse
-from fastapi.staticfiles import StaticFiles
 from markupsafe import Markup
 from packaging.version import InvalidVersion, Version
 
 from . import errors, model, view
+from .static_files import HashedStaticFileHandler
 
 
 @dataclasses.dataclass(frozen=True)
@@ -82,9 +81,9 @@ def __init__(self, model: model.Model, view: view.View) -> None:
         self.model = model
         self.view = view
 
-    def create_router(self, static_file_path: Path) -> fastapi.APIRouter:
+    def create_router(self, static_files_manifest) -> fastapi.APIRouter:
         router = self.router.build_fastapi_router(self)
-        router.mount("/static", StaticFiles(directory=static_file_path), name="static")
+        router.mount("/static", HashedStaticFileHandler(manifest=static_files_manifest), name="static")
         return router
 
     @router.get("/", name="index")

simple_repository_browser/_compile_static.py

@@ -0,0 +1,103 @@
+import argparse
+from hashlib import sha256
+import json
+import os
+import pathlib
+import shutil
+import sys
+import typing
+
+from starlette.responses import FileResponse
+from starlette.staticfiles import StaticFiles
+from typing_extensions import override
+
+
+def compile_static_files(*, destination: pathlib.Path, sources: typing.Sequence[pathlib.Path]):
+    """Compile a static directory from one or more source directories."""
+    # This function is designed to write the static files, could be useful for serving static
+    # files via apache/nginx/etc.
+    manifest = generate_manifest(sources)
+    file_map = {'file-map': {}}
+
+    for input_filename, (hashed_relpath, source_path) in manifest.items():
+        target = destination / hashed_relpath
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(source_path, target)
+        file_map['file-map'][str(input_filename)] = str(target)
+
+    json.dump(file_map, (destination / '.manifest.json').open('w'), indent=2)
+    (destination / '.gitignore').write_text('*')
+
+
+def generate_manifest(sources: typing.Sequence[pathlib.Path]) -> dict[str, tuple[str, pathlib.Path]]:
+    """
+    Generate a manifest which maps template_rel_path to a (hashed_relpath, full_path) tuple.
+    """
+    manifest: dict[str, tuple[str, str]] = {}
+    files_to_compile = {}
+    for source in sources:
+        assert source.exists()
+        for path in sorted(source.glob('**/*')):
+            if not path.is_file():
+                continue
+            if path.name.startswith('.'):
+                continue
+            rel = path.relative_to(source)
+            files_to_compile[rel] = path
+
+    for rel, source_path in files_to_compile.items():
+        file_hash = sha256(source_path.read_bytes()).hexdigest()[:12]
+        name = f'{source_path.stem}.{file_hash}{source_path.suffix}'
+        manifest[str(rel)] = (str(rel.parent / name), source_path)
+
+    return manifest
+
+
+class HashedStaticFileHandler(StaticFiles):
+    def __init__(self, *, manifest, **kwargs):
+        super().__init__(**kwargs)
+        self.manifest = manifest
+        self._inverted_manifest = {src: path for src, path in manifest.values()}
+
+    @override
+    def lookup_path(self, path: str) -> tuple[str, os.stat_result | None]:
+        actual_path = self._inverted_manifest.get(path)
+        if actual_path is None:
+            super.lookup_path(path)
+        return actual_path, os.stat(actual_path)
+
+    @override
+    async def get_response(self, path: str, scope):
+        response: FileResponse = await super().get_response(path, scope)
+        if response.status_code in [200, 304]:
+            response.headers["Cache-Control"] = "public, max-age=31536000, immutable"
+        return response
+
+
+def main(argv: typing.Sequence[str]) -> int:
+    parser = argparse.ArgumentParser(prog='simple_repository_browser.static')
+
+    subparsers = parser.add_subparsers()
+
+    parser_compile_static = subparsers.add_parser('compile', help='Compile the static files into a directory')
+    parser_compile_static.add_argument('destination', type=pathlib.Path, help='Where to write the static files')
+    parser_compile_static.add_argument(
+        'source',
+        type=pathlib.Path,
+        help='The source of static files to combine (may be provided multiple times)',
+        nargs='+',
+    )
+    parser_compile_static.set_defaults(handler=handle_compile)
+
+    args = parser.parse_args(argv)
+    args.handler(args)
+
+
+def handle_compile(args: argparse.Namespace):
+    print(f'Writing static files to {args.destination}')
+    compile_static_files(destination=args.destination, sources=args.source)
+
+
+if __name__ == '__main__':
+    # Enable simple_repository_browser.static_files CLI.
+    main(sys.argv[1:])

simple_repository_browser/controller.py

@@ -1,4 +1,5 @@
 from simple_repository import model
+
 from simple_repository_browser.compatibility_matrix import compatibility_matrix
 
 

simple_repository_browser/static_files.py

@@ -1,5 +1,6 @@
 import parsley
 import pytest
+
 from simple_repository_browser import _search
 from simple_repository_browser._search import Filter, FilterOn
 

simple_repository_browser/tests/test_compatibility_matrix.py

@@ -1,4 +1,5 @@
 from packaging.requirements import Requirement
+
 from simple_repository_browser.view import render_markers