Update from 50e7a22

Author: pelson

javascript/scss/app.scss

@@ -124,3 +124,24 @@ a.status-badge--bad {
 a.status-badge--good {
    background-color: #148024;
 }
+
+img {
+   max-width: 100%;
+}
+
+
+.link-unstyled, .link-unstyled:link, .link-unstyled:hover {
+  color: inherit;
+  text-decoration: inherit;
+}
+
+
+.base-color {
+   background: $base-color !important;
+   color: white !important;
+}
+
+.secondary-color {
+   background: $base-color2 !important;
+   color: white !important;
+}

pyproject.toml

@@ -10,3 +10,10 @@ requires = ["setuptools>=45", "wheel", "setuptools_scm>=6.2"]
 
 [tool.setuptools_scm]
 write_to = "simple_repository_browser/_version.py"
+
+[[tool.mypy.overrides]]
+module = [
+    "diskcache",
+    "parsley",
+]
+ignore_missing_imports = true

setup.py

@@ -16,7 +16,7 @@
 
 REQUIREMENTS: dict = {
     'core': [
-        'aiohttp',
+        'httpx',
         'aiosqlite',
         'diskcache',
         'docutils',
@@ -29,7 +29,7 @@
         'parsley',
         'pkginfo',
         'readme-renderer[md]',
-        'simple-repository',
+        'simple-repository>=0.4',
         'uvicorn',
     ],
     'test': [
@@ -38,6 +38,7 @@
     'dev': [
         'build',
         'pre-commit',
+        'types-setuptools',
     ],
 }
 
@@ -46,7 +47,10 @@
     name='simple-repository-browser',
 
     author="CERN, BE-CSS-SET",
-    description='A web interface to browse and search packages in any simple package repository (PEP-503), inspired by PyPI / warehouse',
+    description=(
+        'A web interface to browse and search packages in any simple package '
+        'repository (PEP-503), inspired by PyPI / warehouse'
+    ),
     long_description=LONG_DESCRIPTION,
     long_description_content_type='text/markdown',
     url="https://github.com/simple-repository/simple-repository-browser",

simple_repository_browser/__main__.py

@@ -32,13 +32,22 @@ def configure_parser(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--cache-dir", type=str, default=Path(os.environ.get('XDG_CACHE_DIR', Path.home() / '.cache')) / 'simple-repository-browser')
     parser.add_argument("--url-prefix", type=str, default="")
     parser.add_argument('--no-popular-project-crawl', dest='crawl_popular_projects', action='store_false', default=True)
+    parser.add_argument('--templates-dir', default=here / "templates", type=Path)
 
 
 def handler(args: typing.Any) -> None:
     app = AppBuilder(
         index_url=args.index_url,
         cache_dir=Path(args.cache_dir),
-        template_paths=[here / "templates", here / "templates" / "base"],
+        template_paths=[
+            args.templates_dir,
+            # Include the base templates so that the given templates directory doesn't have to
+            # implement *all* of the templates. This must be at a lower precedence than the given
+            # templates path, so that they can be overriden.
+            here/"templates"/"base",
+            # Include the "base" folder, such that upstream templates can inherit from "base/...".
+            here/"templates",
+        ],
         static_files_path=here / "static",
         crawl_popular_projects=args.crawl_popular_projects,
         url_prefix=args.url_prefix,

simple_repository_browser/_app.py

@@ -10,10 +10,11 @@
 import typing
 from pathlib import Path
 
-import aiohttp
 import aiosqlite
 import diskcache
 import fastapi
+import httpx
+from simple_repository import SimpleRepository
 from simple_repository.components.http import HttpRepository
 
 from . import controller, crawler, errors, fetch_projects, model, view
@@ -54,12 +55,12 @@ def create_app(self) -> fastapi.FastAPI:
 
         async def lifespan(app: fastapi.FastAPI):
             async with (
-                aiohttp.ClientSession() as session,
+                httpx.AsyncClient() as http_client,
                 aiosqlite.connect(self.db_path, timeout=5) as db,
             ):
                 _controller = self.create_controller(
                     model=self.create_model(
-                        session=session,
+                        http_client=http_client,
                         database=db,
                     ),
                     view=_view,
@@ -100,29 +101,29 @@ async def catch_exceptions_middleware(request: fastapi.Request, call_next):
     def create_view(self) -> view.View:
         return view.View(self.template_paths, self.browser_version)
 
-    def create_crawler(self, session: aiohttp.ClientSession, source: HttpRepository) -> crawler.Crawler:
+    def create_crawler(self, http_client: httpx.AsyncClient, source: SimpleRepository) -> crawler.Crawler:
         return crawler.Crawler(
-            session=session,
+            http_client=http_client,
             crawl_popular_projects=self.crawl_popular_projects,
             source=source,
             projects_db=self.con,
             cache=self.cache,
         )
 
-    def create_model(self, session: aiohttp.ClientSession, database: aiosqlite.Connection) -> model.Model:
+    def create_model(self, http_client: httpx.AsyncClient, database: aiosqlite.Connection) -> model.Model:
         source = MetadataInjector(
             HttpRepository(
                 url=self.index_url,
-                session=session,
+                http_client=http_client,
             ),
             database=database,
-            session=session,
+            http_client=http_client,
         )
         return model.Model(
             source=source,
             projects_db=self.con,
             cache=self.cache,
-            crawler=self.create_crawler(session, source),
+            crawler=self.create_crawler(http_client, source),
         )
 
     def create_controller(self, view: view.View, model: model.Model) -> controller.Controller:

simple_repository_browser/compatibility_matrix.py

@@ -0,0 +1,124 @@
+# Copyright (C) 2023, CERN
+# This software is distributed under the terms of the MIT
+# licence, copied verbatim in the file "LICENSE".
+# In applying this license, CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+import dataclasses
+
+from packaging.utils import parse_wheel_filename
+from packaging.version import Version
+from simple_repository import model
+
+
+@dataclasses.dataclass(frozen=True)
+class CompatibilityMatrixModel:
+    matrix: dict[tuple[str, str], model.File]
+    py_and_abi_names: tuple[str, ...]
+    platform_names: tuple[str, ...]
+
+
+def compatibility_matrix(
+        files: tuple[model.File, ...],
+) -> CompatibilityMatrixModel:
+    """
+    Look at the given files, and compute a compatibility matrix.
+
+    """
+    compat_matrix: dict[tuple[str, str], model.File] = {}
+    # Track the py_abi_names seen, and store a sort key for those names.
+    py_abi_names = {}
+    # Track the platform_names (we sort by name).
+    platform_names = set()
+
+    interpreted_py_abi_tags: dict[tuple[str, str], InterpretedPyAndABITag] = {}
+
+    for file in files:
+        if not file.filename.lower().endswith('.whl'):
+            continue
+        _, _, _, tags = parse_wheel_filename(file.filename)
+
+        # Ensure that the tags have a consistent sort order. From
+        # packaging they come as a frozenset, so no such upstream guarantee is provided.
+        sorted_tags = sorted(tags, key=lambda tag: (tag.platform, tag.abi, tag.interpreter))
+
+        for tag in sorted_tags:
+            inter_abi_key = (tag.interpreter, tag.abi)
+            if inter_abi_key not in interpreted_py_abi_tags:
+                interpreted_py_abi_tags[inter_abi_key] = interpret_py_and_abi_tag(tag.interpreter, tag.abi)
+
+            tag_interp = interpreted_py_abi_tags[inter_abi_key]
+            compat_matrix[(tag_interp.nice_name, tag.platform)] = file
+
+            # Track the seen tags, and define a sort order.
+            py_abi_names[tag_interp.nice_name] = (
+                tag_interp.python_implementation,
+                tag_interp.python_version,
+                tag_interp.nice_name,
+            )
+            platform_names.add(tag.platform)
+
+    r_plat_names = tuple(sorted(platform_names))
+    r_py_abi_names = tuple(sorted(py_abi_names, key=py_abi_names.__getitem__))
+
+    return CompatibilityMatrixModel(compat_matrix, r_py_abi_names, r_plat_names)
+
+
+# https://packaging.python.org/en/latest/specifications/platform-compatibility-tags/#python-tag
+py_tag_implementations = {
+    'py': 'Python',
+    'cp': 'CPython',
+    'ip': 'IronPython',
+    'pp': 'PyPy',
+    'jy': 'Jython',
+}
+
+
+@dataclasses.dataclass(frozen=True)
+class InterpretedPyAndABITag:
+    nice_name: str
+    python_implementation: str | None = None
+    python_version: Version | None = None
+
+
+def interpret_py_and_abi_tag(py_tag: str, abi_tag: str) -> InterpretedPyAndABITag:
+    if py_tag[:2] in py_tag_implementations:
+        py_impl, version_nodot = py_tag[:2], py_tag[2:]
+        py_impl = py_tag_implementations.get(py_impl, py_impl)
+        if '_' in version_nodot:
+            py_version = Version('.'.join(version_nodot.split('_')))
+        elif len(version_nodot) == 1:
+            # e.g. Pure python wheels
+            py_version = Version(version_nodot)
+        else:
+            py_version = Version(f'{version_nodot[0]}.{version_nodot[1:]}')
+
+        if abi_tag.startswith(py_tag):
+            abi_tag_flags = abi_tag[len(py_tag):]
+            if 'd' in abi_tag_flags:
+                abi_tag_flags = abi_tag_flags.replace('d', '')
+                py_impl += ' (debug)'
+            if 'u' in abi_tag_flags:
+                abi_tag_flags = abi_tag_flags.replace('u', '')
+                # A python 2 concept.
+                py_impl += ' (wide)'
+            if 'm' in abi_tag_flags:
+                abi_tag_flags = abi_tag_flags.replace('m', '')
+                pass
+            if abi_tag_flags:
+                py_impl += f' (additional flags: {abi_tag_flags})'
+            return InterpretedPyAndABITag(f'{py_impl} {py_version}', py_impl, py_version)
+        elif abi_tag.startswith('pypy') and py_impl == 'PyPy':
+            abi = abi_tag.split('_')[1]
+            return InterpretedPyAndABITag(f'{py_impl} {py_version} ({abi})', py_impl, py_version)
+        elif abi_tag == 'abi3':
+            # Example PyQt6
+            return InterpretedPyAndABITag(f'{py_impl} >={py_version} (abi3)', py_impl, py_version)
+        elif abi_tag == 'none':
+            # Seen with pydantic-core 2.11.0
+            return InterpretedPyAndABITag(f'{py_impl} {py_version}', py_impl, py_version)
+        else:
+            return InterpretedPyAndABITag(f'{py_impl} {py_version} ({abi_tag})', py_impl, py_version)
+
+    return InterpretedPyAndABITag(f'{py_tag} ({abi_tag})')

simple_repository_browser/controller.py

@@ -6,6 +6,7 @@
 # or submit itself to any jurisdiction.
 
 import asyncio
+import dataclasses
 import typing
 from enum import Enum
 from functools import partial
@@ -20,10 +21,18 @@
 from . import errors, model, view
 
 
+@dataclasses.dataclass(frozen=True)
+class Route:
+    fn: typing.Callable
+    methods: set[str]
+    response_class: typing.Type
+    kwargs: dict[str, typing.Any]
+
+
 class Router:
     # A class-level router definition, capable of generating an instance specific router with its "build_fastapi_router".
     def __init__(self):
-        self._routes_register = {}
+        self._routes_register: dict[str, Route] = {}
 
     def route(
         self,
@@ -33,7 +42,7 @@ def route(
         **kwargs: typing.Any,
     ):
         def dec(fn):
-            self._routes_register[path] = (fn, methods, response_class, kwargs)
+            self._routes_register[path] = Route(fn, methods, response_class, kwargs)
             return fn
         return dec
 
@@ -49,11 +58,22 @@ def head(self, path: str, **kwargs: typing.Any):
     def build_fastapi_router(self, controller: "Controller") -> fastapi.APIRouter:
         router = fastapi.APIRouter()
         for path, route in self._routes_register.items():
-            endpoint, methods, response_class, kwargs = route
-            bound_endpoint = partial(endpoint, controller)
-            router.add_api_route(path=path, endpoint=bound_endpoint, response_class=response_class, methods=methods, **kwargs)
+            bound_endpoint = partial(route.fn, controller)
+            router.add_api_route(
+                path=path,
+                endpoint=bound_endpoint,
+                response_class=route.response_class,
+                methods=list(route.methods),
+                **route.kwargs,
+            )
         return router
 
+    def __iter__(self) -> typing.Iterator[tuple[str, Route]]:
+        return self._routes_register.items().__iter__()
+
+    def update(self, new_values: dict[str, Route]) -> None:
+        self._routes_register.update(new_values)
+
 
 class ProjectPageSection(str, Enum):
     description = "description"
@@ -75,7 +95,7 @@ def create_router(self, static_file_path: Path) -> fastapi.APIRouter:
         return router
 
     @router.get("/", name="index")
-    async def index(self, request: fastapi.Request = None) -> str:
+    async def index(self, request: fastapi.Request) -> str:
         return self.view.index_page(request)
 
     @router.get("/about", name="about")
@@ -96,17 +116,17 @@ async def search(self, request: fastapi.Request, query: str, page: int = 1) -> s
             )
         return self.view.search_page(response, request)
 
-    @router.get("/project/{project_name}", name="project")
-    @router.get("/project/{project_name}/{version}", name='project_version')
-    @router.get("/project/{project_name}/{version}/{page_section}", name='project_version_section')
+    @router.get("/project/{project_name}", name="project", response_model=None)
+    @router.get("/project/{project_name}/{version}", name='project_version', response_model=None)
+    @router.get("/project/{project_name}/{version}/{page_section}", name='project_version_section', response_model=None)
     async def project(
         self,
         request: fastapi.Request,
         project_name: str,
         version: str | None = None,
         page_section: ProjectPageSection | None = ProjectPageSection.description,
         recache: bool = False,
-    ) -> str:
+    ) -> str | StreamingResponse:
         _ = page_section  # Handled in javascript.
         _version = None
         if version: