Files
devplacepy/devplacepy/routers/uploads.py
T
retoorandClaude Sonnet 5.5 bc11475f29 Send per-app provider attribution titles from one gateway app registry
Add openai_gateway/apps.py as the single list of internal gateway apps and
send X-OpenRouter-Title (plus legacy X-Title and HTTP-Referer) per app to
every upstream. Label the Devii agent, bots, modifier, quiz grading, SEO
metadata, community and sync callers. Shorten two app references that
exceeded the 30 character limit and were recorded as default.
Also includes the pending Muse Code, route health and Responses work.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 18:45:09 +01:00

258 lines
9.8 KiB
Python

# retoor <retoor@molodetz.nl>
import base64
import logging
from pathlib import Path
from typing import Annotated
from fastapi import Depends, APIRouter, Request
from fastapi.responses import JSONResponse
from devplacepy.database import (
get_table,
get_int_setting,
get_user_attachments,
get_user_attachment,
)
from devplacepy.models import UploadUrlForm, AttachmentRenameForm, GenerateImageForm
from devplacepy.utils import require_user_api, is_admin, track_action
from devplacepy.attachments import (
store_attachment,
store_attachment_from_url,
soft_delete_attachment,
rename_attachment,
is_extension_allowed,
RemoteFetchError,
)
from devplacepy.schemas import UploadItemOut, UploadsListOut
from urllib.parse import urlparse
from devplacepy.services.audit import record as audit
from devplacepy.dependencies import json_or_form
from devplacepy import stealth
from devplacepy.config import (
INTERNAL_BASE_URL,
INTERNAL_IMAGE_MODEL,
USER_IMAGE_SIZE_DEFAULT,
USER_IMAGE_TIMEOUT_SECONDS,
)
logger = logging.getLogger(__name__)
router = APIRouter()
@router.post("/upload")
async def upload_file(request: Request):
user = require_user_api(request)
form = await request.form()
file = form.get("file")
if not file or not hasattr(file, "filename") or not file.filename:
return JSONResponse({"error": "No file provided"}, status_code=400)
ext = Path(file.filename).suffix.lower()
if not is_extension_allowed(ext):
return JSONResponse(
{"error": f"File type '{ext}' not allowed"}, status_code=415
)
try:
content = await file.read()
except Exception as e:
logger.warning(f"Failed to read uploaded file: {e}")
return JSONResponse({"error": "Failed to read file"}, status_code=400)
result = store_attachment(content, file.filename, user["uid"])
if result is None:
max_size_mb = get_int_setting("max_upload_size_mb", 10)
return JSONResponse(
{"error": f"File exceeds {max_size_mb}MB limit"}, status_code=413
)
logger.info(
f"File uploaded: {file.filename} ({len(content)} bytes) -> {result['url']}"
)
audit.record(
request,
"attachment.upload",
user=user,
target_type="attachment",
target_uid=result.get("uid"),
target_label=file.filename,
metadata={"size": len(content), "mime": result.get("mime_type")},
summary=f"{user['username']} uploaded attachment {file.filename}",
links=[audit.attachment_link(result.get("uid"), file.filename)],
)
track_action(user["uid"], "upload")
return JSONResponse(result, status_code=201)
@router.post("/upload-url")
async def upload_from_url(request: Request, data: Annotated[UploadUrlForm, Depends(json_or_form(UploadUrlForm))]):
user = require_user_api(request)
try:
result = await store_attachment_from_url(data.url, user["uid"], data.filename)
except RemoteFetchError as exc:
return JSONResponse({"error": exc.message}, status_code=exc.status)
logger.info(
f"URL attached: {data.url} ({result['file_size']} bytes) -> {result['url']}"
)
audit.record(
request,
"attachment.upload_url",
user=user,
target_type="attachment",
target_uid=result.get("uid"),
target_label=result.get("filename"),
metadata={"source_host": urlparse(data.url).hostname, "size": result.get("file_size"), "mime": result.get("mime_type")},
summary=f"{user['username']} attached a remote file from {urlparse(data.url).hostname}",
links=[audit.attachment_link(result.get("uid"), result.get("filename"))],
)
return JSONResponse(result, status_code=201)
@router.post("/generate-image")
async def generate_image(request: Request, data: Annotated[GenerateImageForm, Depends(json_or_form(GenerateImageForm))]):
user = require_user_api(request)
body = {
"model": INTERNAL_IMAGE_MODEL,
"prompt": data.prompt,
"size": data.size or USER_IMAGE_SIZE_DEFAULT,
"response_format": "b64_json",
"n": 1,
}
headers = {
"Content-Type": "application/json",
"X-App-Reference": "devplace-image-gen-v-1-0-0",
"Authorization": f"Bearer {user.get('api_key', '')}",
}
try:
async with stealth.stealth_async_client(timeout=USER_IMAGE_TIMEOUT_SECONDS) as client:
response = await client.post(
f"{INTERNAL_BASE_URL}/openai/v1/images/generations", json=body, headers=headers
)
payload = response.json() if response.content else {}
if response.status_code >= 400:
detail = (payload.get("error") or {}).get("message") if isinstance(payload, dict) else None
return JSONResponse(
{"error": detail or f"Image generation failed ({response.status_code})"},
status_code=502,
)
items = payload.get("data") or []
item = items[0] if items else {}
encoded = item.get("b64_json") or ""
if encoded:
content = base64.b64decode(encoded)
elif item.get("url"):
download = await client.get(item["url"])
download.raise_for_status()
content = download.content
else:
return JSONResponse({"error": "Image provider returned no image"}, status_code=502)
except Exception as exc:
logger.warning(f"Image generation failed: {exc}")
return JSONResponse({"error": f"Image generation failed: {exc}"}, status_code=502)
result = store_attachment(content, "generated.png", user["uid"])
if result is None:
return JSONResponse({"error": "Generated image exceeds the upload limit"}, status_code=413)
audit.record(
request,
"attachment.generate_image",
user=user,
target_type="attachment",
target_uid=result.get("uid"),
target_label="generated.png",
metadata={"size": len(content), "prompt": data.prompt[:200]},
summary=f"{user['username']} generated an image",
links=[audit.attachment_link(result.get("uid"), "generated.png")],
)
track_action(user["uid"], "upload")
return JSONResponse(result, status_code=201)
def _linked_filter(linked):
if linked is None:
return None
return linked.strip().lower() in ("1", "true", "yes", "linked")
@router.get("")
async def list_attachments(
request: Request, page: int = 1, linked: str | None = None
):
user = require_user_api(request)
items, pagination = get_user_attachments(
user["uid"], page=page, linked=_linked_filter(linked)
)
payload = {
"attachments": items,
"pagination": pagination,
"total": pagination.get("total", len(items)),
}
return JSONResponse(UploadsListOut.model_validate(payload).model_dump(mode="json"))
@router.get("/{attachment_uid}")
async def get_attachment_route(request: Request, attachment_uid: str):
user = require_user_api(request)
item = get_user_attachment(attachment_uid)
if not item:
return JSONResponse({"error": "Attachment not found"}, status_code=404)
if item.get("user_uid") and item["user_uid"] != user["uid"] and not is_admin(user):
return JSONResponse({"error": "Not authorized"}, status_code=403)
return JSONResponse(UploadItemOut.model_validate(item).model_dump(mode="json"))
@router.patch("/{attachment_uid}")
async def rename_attachment_route(
request: Request,
attachment_uid: str,
data: Annotated[
AttachmentRenameForm, Depends(json_or_form(AttachmentRenameForm))
],
):
user = require_user_api(request)
att = get_table("attachments").find_one(uid=attachment_uid, deleted_at=None)
if not att:
return JSONResponse({"error": "Attachment not found"}, status_code=404)
if att.get("user_uid") and att["user_uid"] != user["uid"] and not is_admin(user):
return JSONResponse({"error": "Not authorized"}, status_code=403)
old_name = att.get("original_filename")
new_name = rename_attachment(attachment_uid, data.filename)
if new_name is None:
return JSONResponse({"error": "Invalid filename"}, status_code=400)
logger.info(f"Attachment {attachment_uid} renamed to {new_name} by {user['username']}")
audit.record(
request,
"attachment.rename",
user=user,
target_type="attachment",
target_uid=attachment_uid,
target_label=new_name,
old_value=old_name,
new_value=new_name,
summary=f"{user['username']} renamed attachment to {new_name}",
links=[audit.attachment_link(attachment_uid, new_name)],
)
item = get_user_attachment(attachment_uid)
return JSONResponse(UploadItemOut.model_validate(item).model_dump(mode="json"))
@router.delete("/delete/{attachment_uid}")
async def delete_attachment_route(request: Request, attachment_uid: str):
user = require_user_api(request)
att = get_table("attachments").find_one(uid=attachment_uid, deleted_at=None)
if not att:
return JSONResponse({"error": "Attachment not found"}, status_code=404)
if att.get("user_uid") and att["user_uid"] != user["uid"] and not is_admin(user):
return JSONResponse({"error": "Not authorized"}, status_code=403)
soft_delete_attachment(attachment_uid, deleted_by=user["uid"])
logger.info(f"Attachment {attachment_uid} soft-deleted by {user['username']}")
audit.record(
request,
"attachment.delete",
user=user,
target_type="attachment",
target_uid=attachment_uid,
target_label=att.get("filename"),
summary=f"{user['username']} deleted attachment {att.get('filename') or attachment_uid}",
links=[audit.attachment_link(attachment_uid, att.get("filename"))],
)
return JSONResponse({"status": "deleted"})