Project modernised:

- Removed /view legacy URLs
- Ruff formatting
- Added typing
- UV build and running via uvx
- Static files now under pastezi

Author: Tronic

.gitignore

@@ -1,6 +1,5 @@
-.vscode
-.env
-env
+.*
+!.gitignore
+*.lock
 .DS_Store
 __pycache__
-Pipfile.lock

MANIFEST.in

@@ -23,3 +23,13 @@ A PUT request to site root creates a randomly named paste, while a PUT request t
     wget https://paste.zi.fi/p/your_file.txt
 
 Notice that binary files are not supported and that trailing newlines and such may get altered.
+
+## Run the server
+
+It is recommended to use [uv](https://docs.astral.sh/uv/getting-started/installation/) and [Caddy](https://caddyserver.com/) for deployment beyond localhost.
+
+```sh
+uvx --with git+https://github.com/Tronic/pastezi.git sanic pastezi:app
+```
+
+Set env `SANIC_SERVER_NAME=https://example.com` with an external domain and https if needed.

Pipfile

@@ -1 +1,3 @@
 from .app import app
+
+__all__: list[str] = ["app"]

README.md

@@ -1,6 +1,8 @@
 import sys
 
-print("""\
+
+def main() -> None:
+    print("""\
 Please run with Sanic CLI, not as a module!
 
 # Using Sanic stand-alone server (with your certificates)
@@ -9,4 +11,8 @@
 # Locally/proxied (set SANIC_SERVER_NAME to public URL with no trailing slash)
 SANIC_SERVER_NAME="https://paste.zi.fi" sanic --port 8000 pastezi:app
 """)
-sys.exit(1)
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

pastezi/__init__.py

@@ -1,83 +1,105 @@
 import mimetypes
 from pathlib import Path
+from typing import TYPE_CHECKING
 
-from sanic import Sanic
+from sanic import Request, Sanic
 from sanic.response import empty, html, redirect, text
 
 from . import content, db
 from .layout import Layout
 
+if TYPE_CHECKING:
+    backend: db.Backend
 
-app = Sanic("pastezi", strict_slashes=True)
+app: Sanic = Sanic("pastezi", strict_slashes=True)
 
 app.config.REQUEST_MAX_SIZE = 1_000_000
 
-staticdir = Path(__file__).resolve().parent.parent / "static"
+staticdir = Path(__file__).resolve().parent / "static"
 if not staticdir.is_dir():
     raise RuntimeError(f"Static files not found in {staticdir}")
 app.static("/", staticdir)
 
+
 @app.before_server_start
-async def init(app):
+async def init(app: Sanic) -> None:
     global backend
     backend = db.Backend()
     await backend.start()
 
+
 @app.get("/", name="index")
-@app.get(f"/p/<paste_id>/edit")
-async def edit_paste(req, paste_id=None):
+@app.get("/p/<paste_id>/edit")
+async def edit_paste(req: Request, paste_id: str | None = None):
     paste = paste_id and await backend[paste_id]
     layout = Layout(req)
     return html(layout.edit_paste(paste, paste_id))
 
+
 # Forced raw download - end with filename for wget support
-@app.get(f"/dl/<paste_id>")
-async def download_paste(req, paste_id):
+@app.get("/dl/<paste_id>")
+async def download_paste(req: Request, paste_id: str):
     paste = await backend[paste_id]
-    if not paste: return text(None, status=404)
-    headers = {"content-type": mimetypes.guess_type(paste_id), "content-disposition": "attachment"}
+    if not paste:
+        return empty(status=404)
+    headers = {
+        "content-type": mimetypes.guess_type(paste_id),
+        "content-disposition": "attachment",
+    }
     return text(paste["text"], headers=headers)
 
+
 # View for browser and API depending on accept header
-@app.get(f"/p/<paste_id>/view", name="old_view_paste")
-@app.get(f"/p/<paste_id>")
-async def view_paste(req, paste_id):
+@app.get("/p/<paste_id>")
+async def view_paste(req: Request, paste_id: str):
     paste = await backend[paste_id]
     layout = Layout(req)
-    h = "text/html" in req.headers.get("accept", "")  # Note: "text/html" in req.accept allows */* too!
+    h = "text/html" in req.headers.accept
     if not paste:
         return html(layout.view_paste(None, paste_id), status=404) if h else empty(404)
     return html(layout.view_paste(paste, paste_id)) if h else text(paste["text"])
 
+
 # HTML form API
 @app.post("/")
-async def post_paste(req):
+async def post_paste(req: Request):
     await req.receive_body()
-    paste, paste_id = req.form.get("paste"), req.form.get("paste_id")
-    if not paste and "paste" in req.files:
+    if not req.form or not req.files:
+        raise ValueError("No form data received")
+
+    paste = req.form.get("paste")
+    paste_id = req.form.get("paste_id")
+    if not paste and req.files and "paste" in req.files:
         mime, paste, paste_id = req.files["paste"][0]
-    paste_id, paste_object = await content.process_paste(paste, paste_id, fallback_charset=req.args.get("charset"))
+    paste_id, paste_object = await content.process_paste(
+        paste, paste_id, fallback_charset=req.args.get("charset")
+    )
     created = await backend.store(paste_id, paste_object)
-    url = get_url(req, paste_id)
-    if "text/html" in req.headers.getone("accept", "*/*"):
+    url = req.url_for("view_paste", paste_id=paste_id)
+    if "text/html" in req.headers.accept:
         return redirect(url)
     else:
         status = 201 if created else 200
         return text(f"{url}\n", status=status)
 
+
 # CRUD API
 
+
 @app.put("/", name="put_paste_noid")
 @app.put("/p/", name="put_paste_noid2")
 @app.put("/p/<paste_id>")
 async def put_paste(req, paste_id=None):
     await req.receive_body()
-    paste_id, paste_object = await content.process_paste(req.body, paste_id, fallback_charset=req.args.get("charset"))
+    paste_id, paste_object = await content.process_paste(
+        req.body, paste_id, fallback_charset=req.args.get("charset")
+    )
     created = await backend.store(paste_id, paste_object)
     status = 201 if created else 200
     url = req.url_for("view_paste", paste_id=paste_id)
     return text(f"{url}\n", status=status)
 
+
 @app.delete("/p/<paste_id>")
 async def delete_paste(req, paste_id):
     deleted = await backend.delete(paste_id)

pastezi/__main__.py

@@ -1,12 +1,14 @@
+import re
+
 import pygments
-from pygments.lexers import get_lexer_for_filename, guess_lexer
-from pygments.formatters import HtmlFormatter  # pylint: disable=no-name-in-module
-import re, os
-from .helper import make_async
-from sanic.exceptions import NotFound, InvalidUsage
 from pronounceable import PronounceableWord
+from pygments.formatters import HtmlFormatter  # type: ignore
+from pygments.lexers import get_lexer_for_filename
+from sanic.exceptions import InvalidUsage
 
-matchers = (
+from .helper import make_async
+
+matchers: list[tuple[str, re.Pattern[str]]] = [
     # First try shebangs and other things at the beginning of the file
     (".sh", re.compile(r"^#!/bin/(ba)?sh\s")),
     (".scala", re.compile(r"^#!/.*scala\s")),
@@ -25,10 +27,23 @@
     (".java", re.compile(r"^public class \w+", re.MULTILINE)),
     (".cpp", re.compile(r"#include .*\w::\w|using namespace \w+;", re.DOTALL)),
     (".c", re.compile(r"#include .*(malloc|printf)\(|int main\(void\)", re.DOTALL)),
-    (".js", re.compile(r"^\s*console.log\(|^\s*(var|let|const) \w+ = require|\) => {$|^\s*function( \w+)?\(", re.MULTILINE)),
+    (
+        ".js",
+        re.compile(
+            r"^\s*console.log\(|^\s*(var|let|const) \w+ = require|\) => {$|^\s*function( \w+)?\(",
+            re.MULTILINE,
+        ),
+    ),
     (".php", re.compile(r"<\?php.*\?>")),
-    (".css", re.compile(r"^\s*(color: *#[0-9a-fA-F]{3,6}|width: \d+(px|r?em|%));$", re.IGNORECASE | re.MULTILINE)),
-)
+    (
+        ".css",
+        re.compile(
+            r"^\s*(color: *#[0-9a-fA-F]{3,6}|width: \d+(px|r?em|%));$",
+            re.IGNORECASE | re.MULTILINE,
+        ),
+    ),
+]
+
 
 class Formatter(HtmlFormatter):
     # Link & anchor line numbers
@@ -37,55 +52,82 @@ def _wrap_lineanchors(self, inner):
         for t, line in inner:
             if t:
                 i += 1
-                yield 1, f'<a class=line href=#{i} id={i} tabindex=-1></a>' + line
+                yield 1, f"<a class=line href=#{i} id={i} tabindex=-1></a>" + line
             else:
                 yield 0, line
+
     # A bit shorter wrapper, and link URLs
     def _wrap_pre(self, inner):
-        yield 0, '<pre><code>'
+        yield 0, "<pre><code>"
         for i, t in inner:
             if i == 1:
-                t = re.sub(r'(http[s]?://\S+)', r'<a href="\1">\1</a>', t)
+                t = re.sub(r"(http[s]?://\S+)", r'<a href="\1">\1</a>', t)
             yield i, t
-        yield 0, '</code></pre>'
+        yield 0, "</code></pre>"
+
 
-def prettyprint(paste, paste_id):
-    n = 1 + re.search("^\s*", paste)[0].count("\n")  # Pygments removes initial empty lines, account for that
+def prettyprint(paste: str, paste_id: str) -> str:
+    # Pygments removes initial empty lines, account for that
+    initialws = re.search(r"^\s*", paste)
+    n = 1 + initialws[0].count("\n") if initialws else 1
     formatter = Formatter(lineanchors=True, linenostart=n)
-    try: lexer = get_lexer_for_filename(paste_id)
-    except Exception: lexer = get_lexer_for_filename(paste_id + ".txt")
+    try:
+        lexer = get_lexer_for_filename(paste_id)
+    except Exception:
+        lexer = get_lexer_for_filename(paste_id + ".txt")
     return pygments.highlight(paste, lexer, formatter)
 
-def decode(text: bytes, fallback_charset: str = None) -> str:
+
+def decode(text: bytes, fallback_charset: str | None = None) -> str:
     """Decode with charset autodetection. Removes Unicode BOMs automatically."""
     # Unicode strings with BOMs
-    boms = (b"\xEF\xBB\xBF", "UTF-8"), (b"\xFF\xFE", "UTF-16LE"), (b"\xFE\xFF", "UTF-16BE"), (b"\xFF\xFE\0\0", "UTF-32LE"), (b"\0\0\xFE\xFF", "UTF-32BE")
+    boms = (
+        (b"\xef\xbb\xbf", "UTF-8"),
+        (b"\xff\xfe", "UTF-16LE"),
+        (b"\xfe\xff", "UTF-16BE"),
+        (b"\xff\xfe\0\0", "UTF-32LE"),
+        (b"\0\0\xfe\xff", "UTF-32BE"),
+    )
     for bom, charset in boms:
-        if text.startswith(bom): return text[len(bom):].decode(charset, errors="replace")
+        if text.startswith(bom):
+            return text[len(bom) :].decode(charset, errors="replace")
     # Try UTF-8 without BOM
-    try: return text.decode()
-    except UnicodeDecodeError: pass
+    try:
+        return text.decode()
+    except UnicodeDecodeError:
+        pass
     # If fallback is provided, just use that
-    if fallback_charset: return text.decode(fallback_charset, errors="replace")
+    if fallback_charset:
+        return text.decode(fallback_charset, errors="replace")
     # 8-bit guesswork
     # - NUL usually means binary data (could be actual NUL or UTF-16/32 w/o BOM, but all those are rare)
-    if 0 in text: raise InvalidUsage("Looks like binary data")
+    if 0 in text:
+        raise InvalidUsage("Looks like binary data")
     # - With CR/LF line terminators, CP437 umlauts are more likely than ISO-8859-1 extended control chars
-    if any(0x80 <= ch < 0xA0 for ch in text) and b"\r\n" in text: return text.decode("CP437")
+    if any(0x80 <= ch < 0xA0 for ch in text) and b"\r\n" in text:
+        return text.decode("CP437")
     # - The most common 8-bit encoding is a reasonable final fallback
     return text.decode("ISO-8859-1")
 
+
 @make_async
-def process_paste(paste, paste_id, fallback_charset = None):
-    if isinstance(paste, bytes): paste = decode(paste, fallback_charset)
-    elif paste is None: raise InvalidUsage("Malformed request (no paste found)")
-    elif paste[0] == "\uFEFF": paste = paste[1:]  # Remove Unicode BOM
+def process_paste(paste, paste_id, fallback_charset=None):
+    if isinstance(paste, bytes):
+        paste = decode(paste, fallback_charset)
+    elif paste is None:
+        raise InvalidUsage("Malformed request (no paste found)")
+    elif paste[0] == "\ufeff":
+        paste = paste[1:]  # Remove Unicode BOM
     paste = paste.replace("\r\n", "\n")
-    if not paste.strip(): raise InvalidUsage("Empty paste (no data found)")
-    if not paste.endswith("\n"): paste += "\n"
+    if not paste.strip():
+        raise InvalidUsage("Empty paste (no data found)")
+    if not paste.endswith("\n"):
+        paste += "\n"
     if paste_id:
-        paste_id = "".join([c for c in paste_id.replace(" ", "_") if re.match(r'[-_\w\.]', c)])
+        paste_id = "".join(
+            [c for c in paste_id.replace(" ", "_") if re.match(r"[-_\w\.]", c)]
+        )
     if not paste_id or len(paste_id) < 3:
         ext = next((e for e, r in matchers if r.search(paste)), ".txt")
-        paste_id = PronounceableWord().length(6, 15) + ext
+        paste_id = PronounceableWord().length(6, 15) + ext  # type: ignore
     return paste_id, dict(text=paste, html=prettyprint(paste, paste_id))

pastezi/app.py

@@ -1,28 +1,39 @@
+from typing import Any, Dict, Optional
+
 from redis import asyncio as aioredis
 
+
 class Backend:
+    expiration: int
+    ns: str
+    redis: Optional[aioredis.Redis]
+
     def __init__(self):
         self.expiration = 365 * 86400  # One year
         self.ns = "pastezi:"
         self.redis = None
 
-    async def start(self):
-        self.redis = await aioredis.from_url('redis://localhost', decode_responses=True)
+    async def start(self) -> None:
+        self.redis = await aioredis.from_url("redis://localhost", decode_responses=True)
 
-    async def __getitem__(self, id):
+    async def __getitem__(self, id: str) -> Optional[Dict[str, Any]]:
+        assert self.redis is not None
         id = self.ns + id
-        value = await self.redis.hgetall(id) or None
-        if value: await self.redis.expire(id, self.expiration)
+        value = await self.redis.hgetall(id) or None  # type: ignore[awaitable]
+        if value:
+            await self.redis.expire(id, self.expiration)
         return value
 
-    async def store(self, id, value):
+    async def store(self, id: str, value: Dict[str, Any]) -> bool:
+        assert self.redis is not None
         id = self.ns + id
         created = not await self.redis.exists(id)
-        await self.redis.hset(id, mapping=value)
+        await self.redis.hset(id, mapping=value)  # type: ignore[awaitable]
         await self.redis.expire(id, self.expiration)
         return created
 
-    async def delete(self, id):
+    async def delete(self, id: str) -> bool:
+        assert self.redis is not None
         id = self.ns + id
         deleted = await self.redis.exists(id)
         await self.redis.delete(id)