pste-server 0.1.0__py3-none-any.whl

pste_server/admin.py

@@ -0,0 +1,209 @@
+import os
+import re
+import secrets
+import string
+import sys
+from datetime import datetime
+
+import click
+from sqlalchemy.orm import sessionmaker
+
+from pste_server.models import Key, Paste, get_engine
+
+_KEY_RE = re.compile(r"^[A-Za-z0-9]+$")
+_KEY_ALPHABET = string.ascii_letters + string.digits
+
+
+def _generate_key(length: int = 32) -> str:
+    return "".join(secrets.choice(_KEY_ALPHABET) for _ in range(length))
+
+
+def _get_db():
+    Session = sessionmaker(bind=get_engine())
+    return Session()
+
+
+def _fmt_dt(dt: datetime | None) -> str:
+    if dt is None:
+        return ""
+    return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
+@click.group()
+def cli():
+    """pste server administration tool."""
+
+
+@cli.group()
+def key():
+    """Manage API keys."""
+
+
+@key.command("add")
+@click.option("--key", "key_val", default=None, help="Key value (generated if omitted; must be [A-Za-z0-9])")
+@click.option("--user", default=None, help="Human identifier (name, email, etc.)")
+@click.option("--notes", default=None, help="Freeform notes")
+def key_add(key_val, user, notes):
+    """Generate and store a new API key."""
+    if key_val is not None:
+        if not _KEY_RE.match(key_val):
+            click.echo("Error: --key must contain only [A-Za-z0-9]", err=True)
+            sys.exit(1)
+    else:
+        key_val = _generate_key()
+    db = _get_db()
+    try:
+        if db.query(Key).filter(Key.key == key_val).first():
+            click.echo("Error: key already exists", err=True)
+            sys.exit(1)
+        k = Key(key=key_val, user=user, notes=notes, disabled=False)
+        db.add(k)
+        db.commit()
+        base_url = os.environ.get("BASE_URL", "http://localhost:8000").rstrip("/")
+        click.echo(f"{base_url}/?key={key_val}")
+    finally:
+        db.close()
+
+
+@key.command("list")
+def key_list():
+    """List all API keys."""
+    db = _get_db()
+    try:
+        keys = db.query(Key).order_by(Key.created_at).all()
+        if not keys:
+            click.echo("No keys found.")
+            return
+        fmt = "{:<44} {:<20} {:<8} {:<19} {}"
+        click.echo(fmt.format("KEY", "USER", "DISABLED", "CREATED", "NOTES"))
+        click.echo("-" * 100)
+        for k in keys:
+            click.echo(fmt.format(
+                k.key[:43],
+                (k.user or "")[:19],
+                "yes" if k.disabled else "no",
+                _fmt_dt(k.created_at),
+                k.notes or "",
+            ))
+    finally:
+        db.close()
+
+
+@key.command("set")
+@click.option("--key", "key_val", default=None, help="Match by key value")
+@click.option("--user", "user_match", default=None, help="Match by user (updates all matching)")
+@click.option("--set-user", default=None, help="New user value")
+@click.option("--notes", default=None, help="New notes value")
+@click.option("--disabled", default=None, type=click.Choice(["true", "false"]), help="Enable/disable key")
+def key_set(key_val, user_match, set_user, notes, disabled):
+    """Modify key fields. Match by --key or --user."""
+    if not key_val and not user_match:
+        click.echo("Error: must provide --key or --user to match", err=True)
+        sys.exit(1)
+
+    db = _get_db()
+    try:
+        q = db.query(Key)
+        if key_val:
+            q = q.filter(Key.key == key_val)
+        if user_match:
+            q = q.filter(Key.user == user_match)
+        keys = q.all()
+        if not keys:
+            click.echo("No matching keys found.", err=True)
+            sys.exit(1)
+
+        for k in keys:
+            if set_user is not None:
+                k.user = set_user
+            if notes is not None:
+                k.notes = notes
+            if disabled is not None:
+                k.disabled = disabled == "true"
+        db.commit()
+        click.echo(f"Updated {len(keys)} key(s).")
+    finally:
+        db.close()
+
+
+@key.command("revoke")
+@click.option("--key", "key_val", default=None, help="Revoke key by exact value")
+@click.option("--user", "user_match", default=None, help="Revoke all keys for this user (with confirmation)")
+@click.option("--notes", "notes_match", default=None, help="Revoke all keys with these notes (with confirmation)")
+def key_revoke(key_val, user_match, notes_match):
+    """Disable one or more keys (soft revoke)."""
+    if not any([key_val, user_match, notes_match]):
+        click.echo("Error: must provide --key, --user, or --notes", err=True)
+        sys.exit(1)
+
+    db = _get_db()
+    try:
+        q = db.query(Key)
+        if key_val:
+            q = q.filter(Key.key == key_val)
+        if user_match:
+            q = q.filter(Key.user == user_match)
+        if notes_match:
+            q = q.filter(Key.notes == notes_match)
+        keys = q.all()
+
+        if not keys:
+            click.echo("No matching keys found.", err=True)
+            sys.exit(1)
+
+        # Require confirmation when matching by user or notes (potentially bulk)
+        if user_match or notes_match:
+            click.echo(f"Keys to revoke ({len(keys)}):")
+            for k in keys:
+                click.echo(f"  {k.key[:16]}...  user={k.user or ''}  notes={k.notes or ''}")
+            if not click.confirm(f"Revoke {len(keys)} key(s)?", default=False):
+                click.echo("Cancelled.")
+                return
+
+        for k in keys:
+            k.disabled = True
+        db.commit()
+        click.echo(f"Revoked {len(keys)} key(s).")
+    finally:
+        db.close()
+
+
+@cli.group()
+def paste():
+    """Manage pastes."""
+
+
+@paste.command("list")
+@click.option("--user", default=None, help="Filter by creating user")
+@click.option("--key", "key_val", default=None, help="Filter by API key")
+def paste_list(user, key_val):
+    """List pastes."""
+    db = _get_db()
+    try:
+        q = db.query(Paste)
+        if key_val:
+            q = q.filter(Paste.created_by == key_val)
+        if user:
+            q = q.join(Key, Paste.created_by == Key.key).filter(Key.user == user)
+        pastes = q.order_by(Paste.created_at.desc()).limit(200).all()
+        if not pastes:
+            click.echo("No pastes found.")
+            return
+        fmt = "{:<10} {:<19} {:<10} {:<44} {:<19} {}"
+        click.echo(fmt.format("ID", "CREATED", "LANG", "CREATED_BY", "DELETED", "REASON"))
+        click.echo("-" * 120)
+        for p in pastes:
+            click.echo(fmt.format(
+                p.id,
+                _fmt_dt(p.created_at),
+                p.lang or "",
+                (p.created_by or "")[:43],
+                _fmt_dt(p.deleted_at),
+                p.deleted_reason or "",
+            ))
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    cli()

pste_server/config.py

@@ -0,0 +1,41 @@
+import os
+import re
+from datetime import timedelta
+
+_DURATION_RE = re.compile(r"^(\d+)([HMWDhmwd])$")
+_UNIT_SECONDS = {"H": 3600, "D": 86400, "W": 7 * 86400, "M": 60}
+
+
+def _bool_env(name: str, default: bool = False) -> bool:
+    return os.environ.get(name, str(default)).lower() in ("1", "true", "yes")
+
+
+def _duration_env(name: str, default: str = "") -> timedelta | None:
+    val = os.environ.get(name, default).strip()
+    if not val:
+        return None
+    m = _DURATION_RE.match(val)
+    if not m:
+        raise ValueError(
+            f"Invalid {name} value {val!r} — expected e.g. 12H, 7D, 2W, 3M"
+        )
+    n, unit = int(m.group(1)), m.group(2).upper()
+    return timedelta(seconds=n * _UNIT_SECONDS[unit])
+
+
+def hard_delete_on_expire() -> bool:
+    return _bool_env("DELETE_ON_EXPIRE", False)
+
+
+def hard_delete_on_single_view() -> bool:
+    return _bool_env("DELETE_ON_SINGLE_VIEW", False)
+
+
+def delete_after_expire() -> timedelta | None:
+    """Hard-delete soft-deleted expired pastes after this duration (independent of DELETE_ON_EXPIRE)."""
+    return _duration_env("DELETE_AFTER_EXPIRE", "7D")
+
+
+def delete_after_single_view() -> timedelta | None:
+    """Hard-delete soft-deleted single-view pastes after this duration (independent of DELETE_ON_SINGLE_VIEW)."""
+    return _duration_env("DELETE_AFTER_SINGLE_VIEW", "7D")

pste_server/id_gen.py

@@ -0,0 +1,50 @@
+import logging
+import secrets
+import string
+
+ALPHABET = string.ascii_uppercase + string.digits  # [A-Z0-9], 36 chars
+
+_id_length_cache: int | None = None
+
+
+def get_id_length(db) -> int:
+    global _id_length_cache
+    if _id_length_cache is not None:
+        return _id_length_cache
+    from pste_server.models import ServerState
+    row = db.query(ServerState).filter_by(key="id_length").first()
+    if row is None:
+        from sqlalchemy.exc import IntegrityError
+        try:
+            row = ServerState(key="id_length", value="6")
+            db.add(row)
+            db.commit()
+        except IntegrityError:
+            db.rollback()
+            row = db.query(ServerState).filter_by(key="id_length").first()
+    _id_length_cache = int(row.value)
+    return _id_length_cache
+
+
+def bump_id_length_if_needed(total_paste_count: int, db) -> None:
+    global _id_length_cache
+    from pste_server.models import ServerState
+    length = get_id_length(db)
+    threshold = int((36 ** length) * 0.01)
+    if total_paste_count >= threshold:
+        new_length = length + 1
+        row = db.query(ServerState).filter_by(key="id_length").first()
+        if row:
+            row.value = str(new_length)
+        else:
+            db.add(ServerState(key="id_length", value=str(new_length)))
+        db.commit()
+        _id_length_cache = new_length
+        logging.warning(
+            "Paste count %d reached 1%% of 36^%d (%d); bumping ID length to %d",
+            total_paste_count, length, threshold, new_length,
+        )
+
+
+def generate_id(length: int) -> str:
+    return "".join(secrets.choice(ALPHABET) for _ in range(length))

pste_server/main.py

@@ -0,0 +1,398 @@
+import html as _html
+import os
+from contextlib import asynccontextmanager
+from datetime import datetime, timezone
+
+from fastapi import Depends, FastAPI, Form, Header, HTTPException, Request
+from fastapi.responses import HTMLResponse, PlainTextResponse, Response
+from pygments import highlight
+from pygments.formatters import HtmlFormatter
+from pygments.lexers import get_lexer_by_name, guess_lexer
+from pygments.util import ClassNotFound
+from sqlalchemy import delete as sa_delete, update as sa_update
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+
+from pste_server.config import hard_delete_on_single_view
+from pste_server.id_gen import generate_id, get_id_length
+from pste_server.models import Key, Paste, get_engine, get_session
+from pste_server.reaper import schedule_paste_expiry, start_reaper, stop_reaper
+from pste_server.storage import get_storage
+from pste_server.validation import (
+    ALLOWED_POST_FIELDS,
+    validate_content,
+    validate_expires_at,
+    validate_expires_in,
+    validate_lang,
+)
+
+BASE_URL = os.environ.get("BASE_URL", "http://localhost:8000").rstrip("/")
+
+_DARK_MODE = os.environ.get("DARK_MODE", "").lower() in ("1", "true", "yes")
+HIGHLIGHT_STYLE = os.environ.get("HIGHLIGHT_STYLE", "github-dark" if _DARK_MODE else "default")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    get_engine()
+    start_reaper()
+    yield
+    stop_reaper()
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+@app.middleware("http")
+async def add_source_header(request, call_next):
+    response = await call_next(request)
+    response.headers["X-Source"] = "https://github.com/crognlie/pste"
+    return response
+
+
+@app.middleware("http")
+async def rate_limit(request: Request, call_next):
+    from pste_server.ratelimit import is_allowed
+    if not is_allowed(request):
+        return Response("Too Many Requests\n", status_code=429, media_type="text/plain")
+    return await call_next(request)
+
+
+def _auth_key(authorization: str | None, db: Session) -> Key:
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Missing or invalid Authorization header")
+    token = authorization[len("Bearer "):]
+    key = db.query(Key).filter(Key.key == token).first()
+    if not key:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+    if key.disabled:
+        raise HTTPException(status_code=403, detail="API key is disabled")
+    return key
+
+
+def _render_highlighted(content: str, lang: str, headers: dict | None = None) -> Response:
+    try:
+        lexer = get_lexer_by_name(lang)
+    except ClassNotFound:
+        lexer = get_lexer_by_name("text")
+    formatter = HtmlFormatter(style=HIGHLIGHT_STYLE, lineanchors="n", linenos="table")
+    code_html = highlight(content, lexer, formatter)
+    style_defs = formatter.get_style_defs(".highlight")
+    full_html = (
+        "<!DOCTYPE html><html><head><meta charset='UTF-8'><style>"
+        f"{style_defs}"
+        # Line numbers are in a separate column — suppress selection so
+        # Ctrl-A copies only the paste content, not the line numbers.
+        " td.linenos { user-select: none; -webkit-user-select: none; }"
+        " body { margin: 1em; }"
+        " #copy-btn { margin-bottom: 0.5em; cursor: pointer; }"
+        "</style></head><body>"
+        "<button id='copy-btn' onclick=\""
+        "var b=document.getElementById('copy-btn');"
+        "navigator.clipboard.writeText(document.querySelector('td.code pre').textContent)"
+        ".then(function(){b.textContent='Copied!';setTimeout(function(){b.textContent='Copy';},2000);});"
+        "\">Copy</button><br>"
+        f"{code_html}"
+        "</body></html>"
+    )
+    return Response(content=full_html, media_type="text/html; charset=UTF-8", headers=headers)
+
+
+_LANG_OPTIONS = [
+    ("", "auto-detect"),
+    ("bash", "Bash"),
+    ("c", "C"),
+    ("cpp", "C++"),
+    ("css", "CSS"),
+    ("diff", "Diff"),
+    ("docker", "Dockerfile"),
+    ("go", "Go"),
+    ("html", "HTML"),
+    ("java", "Java"),
+    ("javascript", "JavaScript"),
+    ("json", "JSON"),
+    ("kotlin", "Kotlin"),
+    ("lua", "Lua"),
+    ("make", "Makefile"),
+    ("markdown", "Markdown"),
+    ("nginx", "Nginx"),
+    ("php", "PHP"),
+    ("python", "Python"),
+    ("ruby", "Ruby"),
+    ("rust", "Rust"),
+    ("scala", "Scala"),
+    ("sql", "SQL"),
+    ("swift", "Swift"),
+    ("toml", "TOML"),
+    ("typescript", "TypeScript"),
+    ("xml", "XML"),
+    ("yaml", "YAML"),
+]
+
+
+def _help_page(key: str | None = None) -> str:
+    form_html = ""
+    if key:
+        lang_opts = "\n".join(
+            f'  <option value="{v}">{_html.escape(label)}</option>'
+            for v, label in _LANG_OPTIONS
+        )
+        form_html = f"""
+<form action="/" method="POST" enctype="multipart/form-data">
+  <input type="hidden" name="pste_key" value="{_html.escape(key)}">
+  <input type="hidden" name="auto_detect" value="1">
+  <textarea name="pste" cols="80" rows="24"></textarea><br>
+  <label><input type="checkbox" name="single_view" value="1"> single-view</label>
+  &nbsp; expires: <input type="number" name="expires_in_n" min="1" style="width:4em">
+  <select name="expires_in_unit">
+    <option value="">never</option>
+    <option value="H">hours</option>
+    <option value="D">days</option>
+    <option value="W">weeks</option>
+    <option value="M">minutes</option>
+  </select>
+  &nbsp; lang: <select name="lang">
+{lang_opts}
+  </select>
+  &nbsp; <button type="submit">paste</button>
+</form>"""
+
+    return f"""<html><body><style>a{{text-decoration:none}}</style><pre>
+pste(1)                             PSTE                             pste(1)
+
+NAME
+    pste: self-hosted command line paste server (sprunge-inspired).
+
+SYNOPSIS
+    &lt;command&gt; | curl -F 'pste=&lt;-' -H 'Authorization: Bearer KEY' {BASE_URL}
+    pste &lt; file.txt
+    echo hello | pste
+
+DESCRIPTION
+    GET  {BASE_URL}/&lt;id&gt;         fetch paste as plain text
+    GET  {BASE_URL}/&lt;id&gt;?&lt;lang&gt;  fetch with syntax highlighting
+    POST {BASE_URL}/             create paste (auth required)
+
+EXAMPLES
+    ~$ echo hello | pste
+       {BASE_URL}/AB1234
+    ~$ pste -l go &lt; main.go
+       {BASE_URL}/AB1235?go
+    ~$ pste -l &lt; data.json        # auto-detect language
+       {BASE_URL}/AB1236?json
+    ~$ pste AB1234
+       hello
+    ~$ echo hello | pste -s
+       {BASE_URL}/AB1237        # only viewable once
+    ~$ echo hello | pste -e 7d
+       {BASE_URL}/AB1238        # expires after 7 days
+       # expiry format: &lt;n&gt;H hours · &lt;n&gt;D days · &lt;n&gt;W weeks · &lt;n&gt;M minutes
+       # e.g. 24H, 7D, 2W, 30M
+
+SEE ALSO
+    https://github.com/crognlie/pste
+</pre>
+{form_html}
+</body></html>"""
+
+
+def _result_page(primary_url: str, secondary_url: str | None = None, secondary_label: str | None = None) -> str:
+    secondary = ""
+    if secondary_url and secondary_label:
+        secondary = f'\n<a href="{_html.escape(secondary_url)}">view highlighted ({_html.escape(secondary_label)})</a>'
+    return (
+        f"<html><body><style>a{{text-decoration:none}}</style><pre>"
+        f'<a href="{_html.escape(primary_url)}">{_html.escape(primary_url)}</a>'
+        f"{secondary}"
+        f"</pre></body></html>"
+    )
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index(key: str | None = None):
+    return _help_page(key=key)
+
+
+@app.post("/")
+async def create_paste(
+    request: Request,
+    authorization: str | None = Header(default=None),
+    db: Session = Depends(get_session),
+):
+    form = await request.form()
+
+    # Reject unknown fields. Web form sends pste_key as a proxy for auth.
+    allowed = ALLOWED_POST_FIELDS | {"pste_key"}
+    extra = set(form.keys()) - allowed
+    if extra:
+        raise HTTPException(status_code=422, detail=f"Unknown fields: {sorted(extra)}")
+
+    # Web form uses hidden pste_key field instead of Authorization header
+    web_key = form.get("pste_key")
+    is_web_form = False
+    if web_key and not authorization:
+        authorization = f"Bearer {web_key}"
+        is_web_form = True
+
+    key_obj = _auth_key(authorization, db)
+
+    raw = form.get("pste")
+    if not raw:
+        raise HTTPException(status_code=422, detail="Field 'pste' is required")
+
+    try:
+        content = validate_content(str(raw))
+    except ValueError as e:
+        raise HTTPException(status_code=422, detail=str(e))
+
+    auto_detect_requested = str(form.get("auto_detect", "")).lower() in ("1", "true")
+
+    lang = None
+    explicit_lang = False
+    raw_lang = form.get("lang")
+    if raw_lang:
+        try:
+            lang = validate_lang(str(raw_lang))
+            explicit_lang = True
+        except ValueError as e:
+            raise HTTPException(status_code=422, detail=str(e))
+
+    expires_at = None
+    raw_expires = form.get("expires_at")
+    expires_in_n = str(form.get("expires_in_n", "")).strip()
+    expires_in_unit = str(form.get("expires_in_unit", "")).strip()
+    if raw_expires:
+        try:
+            expires_at = validate_expires_at(str(raw_expires))
+        except ValueError as e:
+            raise HTTPException(status_code=422, detail=str(e))
+    elif expires_in_n and expires_in_unit:
+        try:
+            expires_at = validate_expires_in(expires_in_n, expires_in_unit)
+        except ValueError as e:
+            raise HTTPException(status_code=422, detail=str(e))
+
+    single_view_raw = form.get("single_view", "")
+    single_view = str(single_view_raw).lower() in ("1", "true")
+
+    # Auto-detect language only when explicitly requested (web form or -l flag with no value)
+    auto_lang = None
+    if not lang and auto_detect_requested:
+        try:
+            guessed = guess_lexer(content)
+            score = type(guessed).analyse_text(content)
+            if score > 0.5 and guessed.aliases:
+                auto_lang = guessed.aliases[0]
+                lang = auto_lang
+        except Exception:
+            pass
+
+    storage = get_storage()
+    id_length = get_id_length(db)
+
+    for _ in range(10):
+        paste_id = generate_id(id_length)
+        if db.query(Paste).filter(Paste.id == paste_id).first():
+            continue
+
+        gcs_key = storage.store(paste_id, content)
+
+        paste = Paste(
+            id=paste_id,
+            created_by=key_obj.key,
+            expires_at=expires_at,
+            single_view=single_view,
+            lang=lang,
+            size_bytes=len(content.encode("utf-8")),
+            content=content if gcs_key is None else None,
+            gcs_key=gcs_key,
+        )
+        db.add(paste)
+        try:
+            db.commit()
+            if expires_at is not None:
+                schedule_paste_expiry(paste_id, expires_at)
+            break
+        except IntegrityError:
+            db.rollback()
+            if gcs_key is not None:
+                try:
+                    storage.delete(paste_id, gcs_key)
+                except Exception:
+                    pass
+    else:
+        raise HTTPException(status_code=500, detail="Could not generate unique ID")
+
+    plain_url = f"{BASE_URL}/{paste_id}"
+    highlighted_url = f"{plain_url}?{lang}" if lang else None
+
+    if is_web_form:
+        if explicit_lang:
+            # User picked a language — show the highlighted URL directly
+            return HTMLResponse(_result_page(highlighted_url))
+        elif auto_lang:
+            # Auto-detected — show plain URL and offer highlighted as option
+            return HTMLResponse(_result_page(plain_url, highlighted_url, auto_lang))
+        else:
+            # No lang — plain URL only
+            return HTMLResponse(_result_page(plain_url))
+
+    # API/CLI: return URL with ?lang when lang is known (explicit or detected), plain otherwise
+    return PlainTextResponse((highlighted_url or plain_url) + "\n")
+
+
+@app.get("/{paste_id}")
+async def get_paste(paste_id: str, request: Request, db: Session = Depends(get_session)):
+    paste_id = paste_id.upper()
+
+    query_string = request.url.query
+
+    paste = db.query(Paste).filter(Paste.id == paste_id, Paste.deleted_at.is_(None)).first()
+    if not paste:
+        raise HTTPException(status_code=404, detail=f"{paste_id} not found.")
+
+    created_header = {"X-Pste-Created": paste.created_at.strftime("%Y-%m-%dT%H:%M:%SZ")}
+
+    gcs_key = paste.gcs_key
+    content_inline = paste.content
+    lang = paste.lang
+
+    if paste.single_view:
+        if hard_delete_on_single_view():
+            # Atomic DB delete — whoever wins the race (rowcount==1) serves the content
+            result = db.execute(
+                sa_delete(Paste).where(Paste.id == paste_id, Paste.deleted_at.is_(None))
+            )
+            db.commit()
+            if result.rowcount == 0:
+                raise HTTPException(status_code=404, detail=f"{paste_id} not found.")
+            storage = get_storage()
+            content = storage.retrieve(paste_id, gcs_key, content_inline)
+            storage.delete(paste_id, gcs_key)
+        else:
+            # Atomic soft-delete claim — race loser gets rowcount==0 → 404
+            now = datetime.now(timezone.utc).replace(tzinfo=None)
+            result = db.execute(
+                sa_update(Paste)
+                .where(Paste.id == paste_id, Paste.deleted_at.is_(None))
+                .values(deleted_at=now, deleted_reason="single_view")
+            )
+            db.commit()
+            if result.rowcount == 0:
+                raise HTTPException(status_code=404, detail=f"{paste_id} not found.")
+            storage = get_storage()
+            content = storage.retrieve(paste_id, gcs_key, content_inline)
+    else:
+        storage = get_storage()
+        content = storage.retrieve(paste_id, gcs_key, content_inline)
+
+    if query_string and query_string.lower() != "none":
+        return _render_highlighted(content, query_string, headers=created_header)
+
+    return PlainTextResponse(content + "\n", headers=created_header)
+
+
+def run():
+    import uvicorn
+    port = int(os.environ.get("PORT", 8000))
+    uvicorn.run("pste_server.main:app", host="0.0.0.0", port=port, reload=False)

pste_server/models.py

@@ -0,0 +1,75 @@
+import os
+from datetime import datetime, timezone
+
+from sqlalchemy import (
+    Boolean, Column, DateTime, ForeignKey, Integer, String, Text, create_engine
+)
+from sqlalchemy.orm import DeclarativeBase, sessionmaker
+
+_engine = None
+_SessionLocal = None
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class ServerState(Base):
+    __tablename__ = "server_state"
+
+    key = Column(String, primary_key=True)
+    value = Column(String, nullable=False)
+
+
+class Key(Base):
+    __tablename__ = "keys"
+
+    key = Column(String, primary_key=True)
+    user = Column(String)
+    notes = Column(Text)
+    disabled = Column(Boolean, default=False, nullable=False)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+
+class Paste(Base):
+    __tablename__ = "pastes"
+
+    id = Column(String, primary_key=True)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_by = Column(String, ForeignKey("keys.key"))
+    expires_at = Column(DateTime)
+    single_view = Column(Boolean, default=False, nullable=False)
+    deleted_at = Column(DateTime)
+    deleted_reason = Column(String)
+    lang = Column(String)
+    size_bytes = Column(Integer)
+    content = Column(Text)
+    gcs_key = Column(String)
+
+
+def get_engine():
+    global _engine
+    if _engine is None:
+        backend = os.environ.get("STORAGE_BACKEND", "sqlite")
+        if backend == "sqlite":
+            path = os.environ.get("SQLITE_PATH", "./data/pste.db")
+            os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+            _engine = create_engine(f"sqlite:///{path}", connect_args={"check_same_thread": False})
+        elif backend in ("postgresql", "gcs"):
+            url = os.environ["DATABASE_URL"]
+            _engine = create_engine(url, pool_pre_ping=True)
+        else:
+            raise ValueError(f"Unknown STORAGE_BACKEND: {backend}")
+        Base.metadata.create_all(_engine)
+    return _engine
+
+
+def get_session():
+    global _SessionLocal
+    if _SessionLocal is None:
+        _SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=get_engine())
+    db = _SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

pste_server/ratelimit.py

@@ -0,0 +1,67 @@
+import ipaddress
+import threading
+from collections import defaultdict, deque
+from datetime import datetime, timezone
+
+RATE_LIMIT = 10
+WINDOW_SECONDS = 60
+
+_PRIVATE_NETWORKS = [
+    ipaddress.ip_network("127.0.0.0/8"),
+    ipaddress.ip_network("10.0.0.0/8"),
+    ipaddress.ip_network("172.16.0.0/12"),
+    ipaddress.ip_network("192.168.0.0/16"),
+    ipaddress.ip_network("100.64.0.0/10"),  # Tailscale CGNAT
+    ipaddress.ip_network("::1/128"),
+    ipaddress.ip_network("fc00::/7"),        # IPv6 ULA
+]
+
+_lock = threading.Lock()
+_get_buckets: dict[str, deque] = defaultdict(deque)
+_post_buckets: dict[str, deque] = defaultdict(deque)
+
+
+def _is_private(ip_str: str) -> bool:
+    try:
+        addr = ipaddress.ip_address(ip_str)
+        return any(addr in net for net in _PRIVATE_NETWORKS)
+    except ValueError:
+        return False
+
+
+def _client_ip(request) -> str:
+    direct = request.client.host if request.client else None
+    # Only trust proxy headers when the direct connection is from a known private proxy
+    if direct and _is_private(direct):
+        if xff := request.headers.get("x-forwarded-for"):
+            return xff.split(",")[0].strip()
+        if xri := request.headers.get("x-real-ip"):
+            return xri.strip()
+    return direct or "unknown"
+
+
+def _check(bucket: deque, now: float) -> bool:
+    cutoff = now - WINDOW_SECONDS
+    while bucket and bucket[0] < cutoff:
+        bucket.popleft()
+    if len(bucket) >= RATE_LIMIT:
+        return False
+    bucket.append(now)
+    return True
+
+
+def is_allowed(request) -> bool:
+    ip = _client_ip(request)
+    if _is_private(ip):
+        return True
+    now = datetime.now(timezone.utc).timestamp()
+    method = request.method.upper()
+    with _lock:
+        bucket = _get_buckets[ip] if method in ("GET", "HEAD") else _post_buckets[ip]
+        return _check(bucket, now)
+
+
+def reset():
+    with _lock:
+        _get_buckets.clear()
+        _post_buckets.clear()

pste_server/reaper.py

@@ -0,0 +1,212 @@
+import logging
+import threading
+from datetime import datetime, timedelta, timezone
+
+logger = logging.getLogger(__name__)
+
+_reaper_timer: threading.Timer | None = None
+_paste_timers: dict[str, threading.Timer] = {}
+_paste_timers_lock = threading.Lock()
+
+# Schedule a per-paste timer at creation time for pastes expiring sooner than
+# this window, so they aren't delayed up to 30 min waiting for the next scan.
+_EARLY_SCHEDULE_WINDOW = timedelta(minutes=45)
+
+
+def _expire_paste(paste_id: str):
+    from pste_server.config import hard_delete_on_expire
+    from pste_server.models import Paste, get_engine
+    from sqlalchemy.orm import sessionmaker
+
+    Session = sessionmaker(bind=get_engine())
+    db = Session()
+    try:
+        paste = db.query(Paste).filter(
+            Paste.id == paste_id,
+            Paste.deleted_at.is_(None),
+        ).first()
+        if paste:
+            if hard_delete_on_expire():
+                from pste_server.storage import get_storage
+                gcs_key = paste.gcs_key
+                db.delete(paste)
+                db.commit()
+                logger.info("Hard-deleted expired paste %s", paste_id)
+                try:
+                    get_storage().delete(paste_id, gcs_key)
+                except Exception:
+                    logger.exception("GCS delete failed for expired paste %s (DB row already removed)", paste_id)
+                return
+            else:
+                paste.deleted_at = datetime.now(timezone.utc).replace(tzinfo=None)
+                paste.deleted_reason = "expired"
+                logger.info("Soft-deleted expired paste %s", paste_id)
+            db.commit()
+    except Exception:
+        logger.exception("Error expiring paste %s", paste_id)
+        db.rollback()
+    finally:
+        db.close()
+
+
+def _schedule_timer(paste_id: str, delay: float):
+    """Create, start, and register a per-paste expiry timer. Caller holds _paste_timers_lock."""
+    t = threading.Timer(delay, _expire_paste, args=[paste_id])
+    t.daemon = True
+    t.start()
+    _paste_timers[paste_id] = t
+    logger.debug("Scheduled expiry for %s in %.1fs", paste_id, delay)
+
+
+def schedule_paste_expiry(paste_id: str, expires_at: datetime):
+    """Schedule a per-paste expiry timer if the paste expires within the early window.
+
+    Called at paste creation time to ensure pastes with short expiry times are
+    handled promptly, rather than waiting up to 30 minutes for the next scan.
+    No-op if the paste expires beyond the window or a timer is already active.
+    """
+    now = datetime.now(timezone.utc).replace(tzinfo=None)
+    time_until = expires_at - now
+    if time_until <= timedelta(0) or time_until > _EARLY_SCHEDULE_WINDOW:
+        return
+    delay = time_until.total_seconds()
+    with _paste_timers_lock:
+        existing = _paste_timers.get(paste_id)
+        if existing and existing.is_alive():
+            return
+        dead = [pid for pid, t in _paste_timers.items() if not t.is_alive()]
+        for pid in dead:
+            del _paste_timers[pid]
+        _schedule_timer(paste_id, delay)
+
+
+def _scan_and_schedule():
+    from pste_server.models import Paste, get_engine
+    from sqlalchemy.orm import sessionmaker
+
+    Session = sessionmaker(bind=get_engine())
+    db = Session()
+    try:
+        now = datetime.now(timezone.utc).replace(tzinfo=None)
+        window_end = now + timedelta(minutes=30)
+        upcoming = db.query(Paste).filter(
+            Paste.expires_at.isnot(None),
+            Paste.expires_at > now,
+            Paste.expires_at <= window_end,
+            Paste.deleted_at.is_(None),
+        ).all()
+
+        for paste in upcoming:
+            delay = (paste.expires_at - now).total_seconds()
+            delay = max(0.0, delay)
+            with _paste_timers_lock:
+                existing = _paste_timers.get(paste.id)
+                if existing and existing.is_alive():
+                    continue
+                dead = [pid for pid, t in _paste_timers.items() if not t.is_alive()]
+                for pid in dead:
+                    del _paste_timers[pid]
+                _schedule_timer(paste.id, delay)
+
+        # Also immediately expire anything past due that wasn't caught
+        from pste_server.config import hard_delete_on_expire
+        from pste_server.storage import get_storage
+        overdue = db.query(Paste).filter(
+            Paste.expires_at.isnot(None),
+            Paste.expires_at <= now,
+            Paste.deleted_at.is_(None),
+        ).all()
+        overdue_gcs = []
+        for paste in overdue:
+            if hard_delete_on_expire():
+                overdue_gcs.append((paste.id, paste.gcs_key))
+                db.delete(paste)
+                logger.info("Hard-deleted overdue paste %s", paste.id)
+            else:
+                paste.deleted_at = now
+                paste.deleted_reason = "expired"
+                logger.info("Soft-deleted overdue paste %s", paste.id)
+        if overdue:
+            db.commit()
+            for pid, gkey in overdue_gcs:
+                get_storage().delete(pid, gkey)
+
+        _purge_deferred(db, now)
+
+        total = db.query(Paste).count()
+        from pste_server.id_gen import bump_id_length_if_needed
+        bump_id_length_if_needed(total, db)
+    except Exception:
+        logger.exception("Error in reaper scan")
+        db.rollback()
+    finally:
+        db.close()
+
+    _schedule_next()
+
+
+def _purge_deferred(db, now: datetime):
+    """Hard-delete soft-deleted records that have aged past DELETE_AFTER_* thresholds."""
+    from pste_server.config import delete_after_expire, delete_after_single_view
+
+    after_expire = delete_after_expire()
+    after_sv = delete_after_single_view()
+
+    if not after_expire and not after_sv:
+        return
+
+    reasons = []
+    if after_expire:
+        reasons.append(("expired", after_expire))
+    if after_sv:
+        reasons.append(("single_view", after_sv))
+
+    from pste_server.models import Paste
+    from pste_server.storage import get_storage
+
+    total = 0
+    all_gcs = []
+    storage = get_storage()
+    for reason, delta in reasons:
+        cutoff = now - delta
+        stale = db.query(Paste).filter(
+            Paste.deleted_reason == reason,
+            Paste.deleted_at.isnot(None),
+            Paste.deleted_at <= cutoff,
+        ).all()
+        for paste in stale:
+            all_gcs.append((paste.id, paste.gcs_key))
+            db.delete(paste)
+            logger.info("Purged %s paste %s (deleted_at=%s, cutoff=%s)", reason, paste.id, paste.deleted_at, cutoff)
+        total += len(stale)
+
+    if total:
+        db.commit()
+        for pid, gkey in all_gcs:
+            storage.delete(pid, gkey)
+
+
+def _schedule_next():
+    global _reaper_timer
+    _reaper_timer = threading.Timer(30 * 60, _scan_and_schedule)
+    _reaper_timer.daemon = True
+    _reaper_timer.start()
+
+
+def start_reaper():
+    t = threading.Thread(target=_scan_and_schedule, daemon=True)
+    t.start()
+
+
+def stop_reaper():
+    global _reaper_timer
+    if _reaper_timer:
+        _reaper_timer.cancel()
+        _reaper_timer = None
+    with _paste_timers_lock:
+        for t in _paste_timers.values():
+            t.cancel()
+        _paste_timers.clear()
+    # Note: a timer registered between the last append and this lock acquisition
+    # won't be cancelled here, but all timers are daemon threads so process
+    # exit is clean regardless.

pste_server/storage.py

@@ -0,0 +1,71 @@
+import abc
+import os
+import threading
+
+
+class StorageBackend(abc.ABC):
+    @abc.abstractmethod
+    def store(self, paste_id: str, content: str) -> str | None:
+        """Store content; return gcs_key if using GCS, else None."""
+
+    @abc.abstractmethod
+    def retrieve(self, paste_id: str, gcs_key: str | None, db_content: str | None) -> str:
+        """Return paste content as a string."""
+
+    def delete(self, paste_id: str, gcs_key: str | None) -> None:
+        """Delete stored content. No-op for SQL backends."""
+
+
+class SqlStorage(StorageBackend):
+    def store(self, paste_id: str, content: str) -> None:
+        return None
+
+    def retrieve(self, paste_id: str, gcs_key: str | None, db_content: str | None) -> str:
+        return db_content or ""
+
+
+class GcsStorage(StorageBackend):
+    def __init__(self):
+        try:
+            from google.cloud import storage as gcs
+        except ImportError:
+            raise ImportError(
+                "GCS storage requires the 'gcs' extra: pip install pste-server[gcs]"
+            )
+        self._bucket_name = os.environ["GCS_BUCKET"]
+        self._client = gcs.Client()
+        self._bucket = self._client.bucket(self._bucket_name)
+
+    def store(self, paste_id: str, content: str) -> str:
+        blob = self._bucket.blob(paste_id)
+        blob.upload_from_string(content.encode("utf-8"), content_type="text/plain; charset=UTF-8")
+        return paste_id
+
+    def retrieve(self, paste_id: str, gcs_key: str | None, db_content: str | None) -> str:
+        key = gcs_key or paste_id
+        blob = self._bucket.blob(key)
+        return blob.download_as_text(encoding="utf-8")
+
+    def delete(self, paste_id: str, gcs_key: str | None) -> None:
+        key = gcs_key or paste_id
+        self._bucket.blob(key).delete()
+
+
+_backend: StorageBackend | None = None
+_backend_lock = threading.Lock()
+
+
+def get_storage() -> StorageBackend:
+    global _backend
+    if _backend is not None:
+        return _backend
+    with _backend_lock:
+        if _backend is None:
+            backend_name = os.environ.get("STORAGE_BACKEND", "sqlite")
+            if backend_name in ("sqlite", "postgresql"):
+                _backend = SqlStorage()
+            elif backend_name == "gcs":
+                _backend = GcsStorage()
+            else:
+                raise ValueError(f"Unknown STORAGE_BACKEND: {backend_name}")
+    return _backend

pste_server/validation.py

@@ -0,0 +1,67 @@
+import os
+from datetime import datetime, timedelta, timezone
+
+from pygments.lexers import get_lexer_by_name
+from pygments.util import ClassNotFound
+
+MAX_PASTE_BYTES = int(os.environ.get("MAX_PASTE_BYTES", 1048576))
+
+ALLOWED_POST_FIELDS = {"pste", "lang", "auto_detect", "expires_at", "expires_in_n", "expires_in_unit", "single_view"}
+
+_UNIT_SECONDS = {"H": 3600, "D": 86400, "W": 7 * 86400, "M": 60}
+
+
+def validate_content(content: str) -> str:
+    """Raises ValueError if content is invalid; returns content."""
+    try:
+        encoded = content.encode("utf-8")
+    except UnicodeEncodeError as e:
+        raise ValueError(f"Content must be valid UTF-8: {e}")
+    if len(encoded) > MAX_PASTE_BYTES:
+        raise ValueError(
+            f"Paste exceeds maximum size of {MAX_PASTE_BYTES} bytes "
+            f"(got {len(encoded)} bytes)"
+        )
+    return content
+
+
+def validate_lang(lang: str) -> str:
+    """Raises ValueError if lang is not a known Pygments lexer name."""
+    if lang.lower() == "none":
+        raise ValueError("'none' is reserved; omit lang to store no default")
+    try:
+        get_lexer_by_name(lang)
+    except ClassNotFound:
+        raise ValueError(f"Unknown language/lexer: {lang!r}")
+    return lang
+
+
+def validate_expires_in(n_str: str, unit: str) -> datetime:
+    """Parse expires_in_n + expires_in_unit (web form); raises ValueError if invalid."""
+    try:
+        n = int(n_str)
+        if n <= 0:
+            raise ValueError()
+    except (ValueError, TypeError):
+        raise ValueError(f"expiry amount must be a positive integer, got {n_str!r}")
+    unit = unit.upper()
+    if unit not in _UNIT_SECONDS:
+        raise ValueError(f"expiry unit must be one of H, D, W, M; got {unit!r}")
+    try:
+        return datetime.now(timezone.utc).replace(tzinfo=None) + timedelta(seconds=n * _UNIT_SECONDS[unit])
+    except OverflowError:
+        raise ValueError(f"expiry duration is too large")
+
+
+def validate_expires_at(value: str) -> datetime:
+    """Parse ISO8601 UTC timestamp; raises ValueError if invalid or in the past."""
+    try:
+        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        raise ValueError(f"Invalid expires_at format (expected ISO8601): {value!r}")
+    if dt.tzinfo is None:
+        raise ValueError("expires_at must include timezone (use UTC, e.g. 2026-01-01T00:00:00Z)")
+    dt_utc = dt.astimezone(timezone.utc).replace(tzinfo=None)
+    if dt_utc <= datetime.now(timezone.utc).replace(tzinfo=None):
+        raise ValueError("expires_at must be in the future")
+    return dt_utc

pste_server-0.1.0.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: pste-server
+Version: 0.1.0
+Summary: Self-hosted paste server (sprunge-inspired) with API key auth, soft-delete, and configurable storage
+Project-URL: Homepage, https://github.com/crognlie/pste
+Project-URL: Repository, https://github.com/crognlie/pste
+License: MIT
+Keywords: cli,paste,pastebin,self-hosted,sprunge
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1
+Requires-Dist: fastapi>=0.110
+Requires-Dist: pygments>=2.17
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: uvicorn[standard]>=0.29
+Provides-Extra: gcs
+Requires-Dist: google-cloud-storage>=2.0; extra == 'gcs'
+Requires-Dist: psycopg2-binary>=2.9; extra == 'gcs'
+Provides-Extra: postgresql
+Requires-Dist: psycopg2-binary>=2.9; extra == 'postgresql'
+Provides-Extra: test
+Requires-Dist: httpx2>=0.28; extra == 'test'
+Requires-Dist: pytest-timeout>=2.3; extra == 'test'
+Requires-Dist: pytest>=8.0; extra == 'test'
+Requires-Dist: requests>=2.31; extra == 'test'
+Description-Content-Type: text/markdown
+
+# pste-server
+
+Self-hosted paste server inspired by [sprunge](http://sprunge.us). Pastes are world-readable; creating requires an API key.
+
+**HTTPS is required in production.** API keys appear in the `Authorization` header and in the `/?key=<key>` query string used by the web form — both are exposed over plain HTTP. pste-server speaks plain HTTP on port 8000; use a reverse proxy or tunnel to terminate TLS. See [`examples/Caddyfile`](examples/Caddyfile) and [`examples/compose-cloudflare.yml`](examples/compose-cloudflare.yml).
+
+## Quick start
+
+```bash
+pip install -e .
+BASE_URL=https://pste.example.com pste-server
+
+# Add your first API key — prints the bookmark URL directly
+pste-admin key add --user alice
+# -> https://pste.example.com/?key=AbCd1234...
+
+# Set PSTE_URL on the client to that URL, then:
+echo "hello" | pste
+# -> https://pste.example.com/AB1234
+pste AB1234
+# -> hello
+```
+
+See [`examples/`](examples/) for Docker Compose, Cloudflare Tunnel, and cloud deployment configurations.
+
+## API
+
+```
+GET  /              Help page (add ?key=<key> for the paste web form)
+POST /              Create paste (requires Authorization: Bearer <key>)
+GET  /<id>          Fetch paste as plain text
+GET  /<id>?<lang>   Fetch with Pygments syntax highlighting + copy button
+```
+
+**Creating pastes:**
+
+| Field | Type | Description |
+|---|---|---|
+| `pste` | string | Paste content (required) |
+| `lang` | string | Pygments lexer name for syntax highlighting |
+| `auto_detect` | `1` | Auto-detect language (Pygments, >0.5 confidence threshold) |
+| `single_view` | `1` | Delete after first read |
+| `expires_at` | ISO8601 UTC | Absolute expiry timestamp |
+| `expires_in_n` | integer | Expiry amount (used with `expires_in_unit`) |
+| `expires_in_unit` | H/D/W/M | Expiry unit: hours, days, weeks, minutes |
+
+`lang` and `auto_detect` are mutually exclusive — if `lang` is provided, auto-detection is skipped. `expires_at` and `expires_in_n`/`expires_in_unit` are also mutually exclusive.
+
+**Fetching pastes:**
+
+- `GET /<id>` — always plain text, regardless of stored lang
+- `GET /<id>?<lang>` — Pygments-highlighted HTML with table line numbers (line numbers have `user-select: none` so Ctrl-A copies only code) and a Copy button
+- `GET /<id>?none` — plain text (same as bare GET)
+
+## Web form
+
+Open `/?key=<key>` in a browser to use the paste web form. The key is embedded in the bookmark URL; paste it from `pste-admin key add` output. The form includes:
+
+- Textarea for paste content
+- Single-view checkbox
+- Expiry controls (number + H/D/W/M dropdown)
+- Language dropdown (auto-detect default, 27 common lexers)
+
+When submitted with **language auto-detect** (default), if Pygments identifies the language with >0.5 confidence the result page shows both the plain URL and a highlighted URL. When a **specific language** is selected the result shows only the highlighted `?<lang>` URL.
+
+## Managing API keys
+
+```bash
+# Add a key (prints the full bookmark URL)
+pste-admin key add --user alice --notes "personal laptop"
+
+# Specify your own key value (must be [A-Za-z0-9])
+pste-admin key add --key MySecretKey --user alice
+
+# List all keys
+pste-admin key list
+
+# Revoke by key value (immediate, no confirmation)
+pste-admin key revoke --key <key-value>
+
+# Revoke all keys for a user or matching notes (lists keys, requires y to confirm)
+pste-admin key revoke --user alice
+pste-admin key revoke --notes "old laptop"
+
+# Update key metadata
+pste-admin key set --user alice --notes "rotated 2026-07"
+pste-admin key set --key <key-value> --disabled true
+
+# List pastes (shows ID, created, lang, key, deleted status)
+pste-admin paste list --user alice
+```
+
+Keys take effect immediately — no restart required.
+
+## Environment variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `BASE_URL` | `http://localhost:8000` | Public URL used in paste links and key add output |
+| `PORT` | `8000` | Listen port |
+| `STORAGE_BACKEND` | `sqlite` | `sqlite`, `postgresql`, or `gcs` |
+| `SQLITE_PATH` | `./data/pste.db` | SQLite DB path |
+| `DATABASE_URL` | — | PostgreSQL connection string |
+| `GCS_BUCKET` | — | GCS bucket name |
+| `MAX_PASTE_BYTES` | `1048576` | Max paste size (bytes) |
+| `DARK_MODE` | `false` | Use `github-dark` as the highlight style; default (unset) uses `default` (light) |
+| `HIGHLIGHT_STYLE` | — | Pin to any [Pygments style](https://pygments.org/styles/) name, ignoring `DARK_MODE` |
+
+### Deletion
+
+By default, expired and single-view pastes are **soft-deleted** — `deleted_at` is set and they become inaccessible, but the row is retained. The variables below control hard deletion.
+
+| Variable | Default | Description |
+|---|---|---|
+| `DELETE_ON_EXPIRE` | `false` | Hard-delete immediately on expiry |
+| `DELETE_ON_SINGLE_VIEW` | `false` | Hard-delete immediately on first view |
+| `DELETE_AFTER_EXPIRE` | `7D` | Hard-delete soft-deleted expired rows after this duration |
+| `DELETE_AFTER_SINGLE_VIEW` | `7D` | Hard-delete soft-deleted single-view rows after this duration |
+
+Duration format for `DELETE_AFTER_*`: integer + `H` (hours), `D` (days), `W` (weeks), or `M` (minutes). Set to empty string (`DELETE_AFTER_EXPIRE=`) to disable deferred hard-deletion entirely. `DELETE_AFTER_*` runs on a 30-minute cycle, independently of `DELETE_ON_*`.

pste_server-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pste_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pste_server/admin.py,sha256=U047Mg6MX-o0OoWmjQp--OYws0XwLZ5IJLt4oyiP1cw,6558
+pste_server/config.py,sha256=AIiWgL-_UICNB6Xkp_xeLYYD5F8oPJL-mXJwkQQZ4dQ,1342
+pste_server/id_gen.py,sha256=nqiljDpCjf6NZVONIXBZ_Q1vIx7NZb5J3dLFYLwOp7g,1628
+pste_server/main.py,sha256=EAQlfrh0aQeJhO61YkV4KxRS4iVDEBRxhPeU1ugCKNY,13995
+pste_server/models.py,sha256=ve3uViEYzGT9B_mIT_djt34mVhUBKZIL7H-NQV4SoMo,2182
+pste_server/ratelimit.py,sha256=Z5_nysRQKIOBkbqOcS077XBhgcUFHrD1nGm9YTyyxts,1933
+pste_server/reaper.py,sha256=l612rG1QV3_1QigC_5gFQrjrCN8XgI62R87mensu5jo,7353
+pste_server/storage.py,sha256=mL_2d7eSt7zCxLSt5rC0CSXaW5ocRLGl-5858YFMg5A,2378
+pste_server/validation.py,sha256=eUV3rAQXJ7a0e1s_9JpIfCw8htWCg44absVNkUGmLkg,2576
+pste_server-0.1.0.dist-info/METADATA,sha256=hqpoPpNhhv3MJUHaqohJesfVStQhiLdYZ1pb4L8PHiI,6306
+pste_server-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pste_server-0.1.0.dist-info/entry_points.txt,sha256=sVb9-70pEEY6cmP4FgAPnPpTTGvObjxE8CtObHUh3K4,88
+pste_server-0.1.0.dist-info/RECORD,,

pste_server-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

pste_server-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pste-admin = pste_server.admin:cli
+pste-server = pste_server.main:run