Establish basic file browser and index fallback

sanic/mixins/routes.py

@@ -702,6 +702,8 @@ def static(
         content_type: Optional[bool] = None,
         apply: bool = True,
         resource_type: Optional[str] = None,
+        autoindex: bool = False,
+        index_name: str = "",
     ):
         """
         Register a root to serve files from. The input can either be a
@@ -752,6 +754,8 @@ def static(
             strict_slashes,
             content_type,
             resource_type,
+            autoindex,
+            index_name,
         )
         self._future_statics.add(static)
 
@@ -825,6 +829,8 @@ async def _static_request_handler(
         request,
         content_type=None,
         __file_uri__=None,
+        autoindex=False,
+        index_name="",
     ):
         not_found = FileNotFound(
             "File not found",
@@ -897,7 +903,13 @@ async def _static_request_handler(
                         return await file_stream(
                             file_path, headers=headers, _range=_range
                         )
-                return await file(file_path, headers=headers, _range=_range)
+                return await file(
+                    file_path,
+                    headers=headers,
+                    _range=_range,
+                    autoindex=autoindex,
+                    index_name=index_name,
+                )
         except RangeNotSatisfiable:
             raise
         except FileNotFoundError:
@@ -992,6 +1004,8 @@ def _register_static(
                 static.use_content_range,
                 static.stream_large_files,
                 content_type=static.content_type,
+                autoindex=static.autoindex,
+                index_name=static.index_name,
             )
         )
 

sanic/models/futures.py

@@ -56,6 +56,8 @@ class FutureStatic(NamedTuple):
     strict_slashes: Optional[bool]
     content_type: Optional[bool]
     resource_type: Optional[str]
+    autoindex: bool
+    index_name: str
 
 
 class FutureSignal(NamedTuple):

sanic/response/convenience.py

@@ -3,12 +3,16 @@
 from datetime import datetime, timezone
 from email.utils import formatdate, parsedate_to_datetime
 from mimetypes import guess_type
+from operator import itemgetter
 from os import path
-from pathlib import PurePath
+from pathlib import Path, PurePath
+from stat import S_ISDIR
 from time import time
-from typing import Any, AnyStr, Callable, Dict, Optional, Union
+from typing import Any, AnyStr, Callable, Dict, Iterable, Optional, Union
 from urllib.parse import quote_plus
 
+from html5tagger import Document, E
+
 from sanic.compat import Header, open_async, stat_async
 from sanic.constants import DEFAULT_HTTP_CONTENT_TYPE
 from sanic.helpers import Default, _default
@@ -164,6 +168,8 @@ async def file(
     max_age: Optional[Union[float, int]] = None,
     no_store: Optional[bool] = None,
     _range: Optional[Range] = None,
+    autoindex: bool = False,
+    index_name: str = "",
 ) -> HTTPResponse:
     """Return a response object with file data.
     :param status: HTTP response code. Won't enforce the passed in
@@ -226,16 +232,25 @@ async def file(
 
     filename = filename or path.split(location)[-1]
 
-    async with await open_async(location, mode="rb") as f:
-        if _range:
-            await f.seek(_range.start)
-            out_stream = await f.read(_range.size)
-            headers[
-                "Content-Range"
-            ] = f"bytes {_range.start}-{_range.end}/{_range.total}"
-            status = 206
-        else:
-            out_stream = await f.read()
+    try:
+        async with await open_async(location, mode="rb") as f:
+            if _range:
+                await f.seek(_range.start)
+                out_stream = await f.read(_range.size)
+                headers[
+                    "Content-Range"
+                ] = f"bytes {_range.start}-{_range.end}/{_range.total}"
+                status = 206
+            else:
+                out_stream = await f.read()
+    except IsADirectoryError:
+        if autoindex or index_name:
+            maybe_response = await AutoIndex(
+                Path(location), autoindex, index_name
+            ).handle()
+            if maybe_response:
+                return maybe_response
+        raise
 
     mime_type = mime_type or guess_type(filename)[0] or "text/plain"
     return HTTPResponse(
@@ -331,3 +346,94 @@ async def _streaming_fn(response):
         headers=headers,
         content_type=mime_type,
     )
+
+
+class AutoIndex:
+    STYLE = """
+        html { font-family: sans-serif; }
+        main { padding: 1rem; }
+        table { width: 100%; max-width: 1200px; }
+        td { font-family: monospace; }
+        table.autoindex td:first-child { width: 65% }
+        table.autoindex td:last-child { text-align: right; width: 15%; }
+        span.icon { margin-right: 1rem; }
+        @media (prefers-color-scheme: dark) {
+            html { background: #111; color: #ccc; }
+            a { color: #ccc; }
+            a:visited { color: #777; }
+        }
+    """
+    TITLE = "📁 File browser"
+
+    def __init__(
+        self, directory: Path, autoindex: bool, index_name: str
+    ) -> None:
+        self.directory = directory
+        self.autoindex = autoindex
+        self.index_name = index_name
+
+    async def handle(self):
+        index_file = self.directory / self.index_name
+        if self.autoindex and (not index_file.exists() or not self.index_name):
+            return await self.index()
+
+        if self.index_name:
+            return await file(index_file)
+
+    async def index(self):
+        return html(self.render())
+
+    def render(self) -> str:
+        doc = Document(title=self.TITLE, lang="en")
+        self._head(doc)
+        with doc.main:
+            self._headline(doc)
+            self._file_table(doc)
+        return str(doc)
+
+    def _head(self, doc: Document):
+        doc.head.title(self.TITLE).style(self.STYLE)
+
+    def _headline(self, doc: Document):
+        doc.h1(self.TITLE)
+
+    def _file_table(self, doc: Document):
+        with doc.table(class_="autoindex"):
+            self._parent(doc)
+            for f in self._iter_files():
+                del f["priority"]
+                self._file_cell(doc, **f)
+
+    def _parent(self, doc: Document):
+        self._file_cell(doc, "📁", "..", "", "")
+
+    def _file_cell(
+        self,
+        doc: Document,
+        icon: str,
+        file_name: str,
+        file_access: str,
+        file_size: str,
+    ):
+        first = E.span(icon, class_="icon").a(file_name, href=file_name)
+        doc.tr.td(first).td(file_access).td(file_size)
+
+    def _prepare_file(self, path: Path) -> Dict[str, Union[int, str]]:
+        stat = path.stat()
+        modified = datetime.fromtimestamp(stat.st_mtime)
+        is_dir = S_ISDIR(stat.st_mode)
+        icon = "📁" if is_dir else "📄"
+        file_name = path.name
+        if is_dir:
+            file_name += "/"
+        return {
+            "priority": is_dir * -1,
+            "file_name": file_name,
+            "icon": icon,
+            "file_access": modified.isoformat(),
+            "file_size": stat.st_size,
+        }
+
+    def _iter_files(self) -> Iterable[Dict[str, Any]]:
+        prepared = [self._prepare_file(f) for f in self.directory.iterdir()]
+        return sorted(prepared, key=itemgetter("priority"))