refactor: move metadata extraction to server

Author: arabcoders

API.md

@@ -818,9 +818,45 @@ Each field object can have:
 - `min`, `max` (number, optional): Numeric value constraints
 - `regex` (string, optional): Regular expression pattern for string validation
 - `default` (any, optional): Default value if not provided
+- `extract_regex` (string, optional): Python regular expression used by `/api/metadata/extract` to prefill metadata from a filename
 
 **Notes:**
 - Schema is loaded from `{config_path}/metadata.json`
+- `extract_regex` is interpreted with Python `re` syntax
+
+---
+
+### POST /api/metadata/extract
+
+Extract metadata values from a filename using the configured schema.
+
+**Authentication:** None
+
+**Request Body:**
+```json
+{
+  "filename": "240101 Example Show [youtube-dQw4w9WgXcQ].mp4"
+}
+```
+
+**Response (200):**
+```json
+{
+  "metadata": {
+    "broadcast_date": "2024-01-01",
+    "title": "Example Show",
+    "source": "youtube",
+    "source_id": "dQw4w9WgXcQ"
+  }
+}
+```
+
+**Extraction Rules:**
+1. Fields without `extract_regex` are ignored
+2. The regex is matched against the provided filename with case-insensitive search
+3. Capture group 1 is used when present; otherwise the full match is used
+4. For `date` fields, named groups `year`, `month`, and `day` are combined into `YYYY-MM-DD`
+5. Two-digit years are normalized to `20xx`
 
 ---
 

backend/app/metadata_schema.py

@@ -1,4 +1,5 @@
 import json
+import re
 from datetime import date, datetime
 from pathlib import Path
 from typing import Any
@@ -177,3 +178,41 @@ def validate_metadata(values: dict[str, Any]) -> dict[str, Any]:
         cleaned[key] = val.isoformat() if isinstance(val, (datetime, date)) else val
 
     return cleaned
+
+
+def extract_metadata_from_filename(filename: str) -> dict[str, Any]:
+    """
+    Extract metadata values from a filename using the configured schema.
+
+    Args:
+        filename (str): Filename to inspect.
+
+    Returns:
+        dict[str, Any]: Extracted metadata values.
+
+    """
+    schema: list[dict] = load_schema()
+    extracted: dict[str, Any] = {}
+
+    for field in schema:
+        regex: str | None = field.get("extract_regex")
+        if not regex:
+            continue
+
+        match = re.search(regex, filename, flags=re.IGNORECASE)
+        if not match:
+            continue
+
+        value: Any = match.group(1) if match.lastindex else match.group(0)
+        if field.get("type") == "date":
+            groups = match.groupdict()
+            year = groups.get("year")
+            month = groups.get("month")
+            day = groups.get("day")
+            if year and month and day:
+                full_year = f"20{year}" if len(year) == 2 else year
+                value = f"{full_year}-{month}-{day}"
+
+        extracted[field["key"]] = value
+
+    return extracted

backend/app/routers/metadata.py

@@ -2,7 +2,8 @@
 
 from fastapi import APIRouter
 
-from backend.app.metadata_schema import load_schema, validate_metadata
+from backend.app import schemas
+from backend.app.metadata_schema import extract_metadata_from_filename, load_schema, validate_metadata
 
 router = APIRouter(prefix="/api/metadata", tags=["metadata"])
 
@@ -19,6 +20,21 @@ async def get_metadata_schema() -> dict[str, list[dict]]:
     return {"fields": load_schema()}
 
 
+@router.post("/extract", name="metadata_schema_extract")
+async def extract_metadata_payload(payload: schemas.MetadataExtractRequest) -> schemas.MetadataExtractResponse:
+    """
+    Extract metadata values from a filename.
+
+    Args:
+        payload: Filename payload to inspect.
+
+    Returns:
+        dict: A dictionary containing the extracted metadata.
+
+    """
+    return schemas.MetadataExtractResponse(metadata=extract_metadata_from_filename(payload.filename))
+
+
 @router.post("/validate", name="metadata_schema_validate")
 async def validate_metadata_payload(payload: dict) -> dict[str, dict[str, Any]]:
     """

backend/app/schemas.py

@@ -100,6 +100,14 @@ class UploadRequest(BaseModel):
     size_bytes: int | None = Field(None, gt=0)
 
 
+class MetadataExtractRequest(BaseModel):
+    filename: str = Field(..., min_length=1)
+
+
+class MetadataExtractResponse(BaseModel):
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
 class TokenListResponse(BaseModel):
     tokens: list[TokenAdmin]
     total: int

backend/tests/test_metadata.py

@@ -39,3 +39,73 @@ async def test_metadata_validation_rejects_invalid_option():
         status_code, result = await validate_metadata(client, {"source": "radio"})
         assert status_code == status.HTTP_422_UNPROCESSABLE_CONTENT, "Invalid select option should return 422"
         assert result["detail"]["field"] == "source", "Error should indicate 'source' field"
+
+
+@pytest.mark.asyncio
+async def test_metadata_extraction_returns_matching_fields():
+    schema = [
+        {
+            "key": "broadcast_date",
+            "label": "Broadcast Date",
+            "type": "date",
+            "extract_regex": "(?P<year>\\d{2})(?P<month>\\d{2})(?P<day>\\d{2})",
+        },
+        {
+            "key": "title",
+            "label": "Title",
+            "type": "string",
+            "extract_regex": "^(?:.*?\\b\\d{6,8}\\b\\s*)?(.+?)(?=\\s*[\\[(]|\\.\\w+$)",
+        },
+        {
+            "key": "source",
+            "label": "Source",
+            "type": "select",
+            "extract_regex": "(?:^|[^A-Za-z0-9])((?:youtube|tver))(?:[^A-Za-z0-9]|$)",
+        },
+        {
+            "key": "source_id",
+            "label": "Source ID",
+            "type": "string",
+            "extract_regex": "(?:^|[^A-Za-z0-9])\\[(?:youtube|tver)-([^\\]]+)\\](?:[^A-Za-z0-9]|$)",
+        },
+    ]
+    seed_schema(schema)
+
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://testserver") as client:
+        resp = await client.post(
+            app.url_path_for("metadata_schema_extract"),
+            json={"filename": "240101 Example Show [youtube-dQw4w9WgXcQ].mp4"},
+        )
+
+        assert resp.status_code == status.HTTP_200_OK, "Extraction endpoint should return 200"
+        assert resp.json()["metadata"] == {
+            "broadcast_date": "2024-01-01",
+            "title": "Example Show",
+            "source": "youtube",
+            "source_id": "dQw4w9WgXcQ",
+        }, "Extraction endpoint should return parsed metadata"
+
+
+@pytest.mark.asyncio
+async def test_metadata_extraction_returns_empty_metadata_when_nothing_matches():
+    seed_schema(
+        [
+            {
+                "key": "title",
+                "label": "Title",
+                "type": "string",
+                "extract_regex": "source-(\\w+)",
+            },
+        ]
+    )
+
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://testserver") as client:
+        resp = await client.post(
+            app.url_path_for("metadata_schema_extract"),
+            json={"filename": "plain-file.mp4"},
+        )
+
+        assert resp.status_code == status.HTTP_200_OK, "Extraction endpoint should return 200"
+        assert resp.json()["metadata"] == {}, "Extraction endpoint should return an empty object when nothing matches"

frontend/app/composables/useMetadata.ts

@@ -22,5 +22,17 @@ export function useMetadata() {
     }
   }
 
-  return { isLoading, metadataSchema, fetchMetadata };
+  async function extractMetadata(filename: string): Promise<Record<string, any>> {
+    try {
+      const data = await $fetch<{ metadata: Record<string, any> }>('/api/metadata/extract', {
+        method: 'POST',
+        body: { filename },
+      });
+      return data.metadata || {};
+    } catch {
+      return {};
+    }
+  }
+
+  return { isLoading, metadataSchema, fetchMetadata, extractMetadata };
 }

frontend/app/composables/useMetadataParser.ts

@@ -132,7 +132,6 @@ import type {
 } from '~/types/uploads';
 import { useTokenInfo } from '~/composables/useTokenInfo';
 import { useMetadata } from '~/composables/useMetadata';
-import { useMetadataParser } from '~/composables/useMetadataParser';
 import { validateSlot } from '~/utils/validation';
 import { useTusUpload } from '~/composables/useTusUpload';
 import { useUploadSlots } from '~/composables/useUploadSlots';
@@ -145,8 +144,7 @@ const token = ref<string>((route.params.token as string) || '');
 
 const { tokenInfo, notFound, tokenError, isExpired, isDisabled, shareLinkText, fetchTokenInfo } =
   useTokenInfo(token);
-const { metadataSchema, fetchMetadata } = useMetadata();
-const { applyParsedMeta } = useMetadataParser();
+const { metadataSchema, fetchMetadata, extractMetadata } = useMetadata();
 const { startTusUpload, pauseUpload, resumeUpload } = useTusUpload();
 const { slots, seedSlots, addSlot, unintiatedSlots } = useUploadSlots(metadataSchema);
 const { pollUploadStatus, stopPolling, stopAllPolling } = useUploadPolling();
@@ -211,11 +209,35 @@ async function refreshAll() {
   seedSlots(tokenInfo.value);
 }
 
-function onFile(slot: Slot, e: Event) {
+function buildDefaultMetadataValues() {
+  return Object.fromEntries(metadataSchema.value.map((field) => [field.key, field.default ?? '']));
+}
+
+async function onFile(slot: Slot, e: Event) {
   const target = e.target as HTMLInputElement;
-  slot.file = target.files?.[0] || null;
-  metadataSchema.value.forEach((f) => (slot.values[f.key] = f.default ?? ''));
-  if (slot.file) applyParsedMeta(slot, slot.file.name, metadataSchema.value);
+  const selectedFile = target.files?.[0] || null;
+  const defaultValues = buildDefaultMetadataValues();
+
+  slot.file = selectedFile;
+  slot.values = defaultValues;
+  slot.errors = validateSlot(slot, metadataSchema.value, tokenInfo.value);
+
+  if (!selectedFile) {
+    return;
+  }
+
+  const extractedValues = await extractMetadata(selectedFile.name);
+  if (slot.file !== selectedFile) {
+    return;
+  }
+
+  const nextValues = { ...slot.values };
+  Object.entries(extractedValues).forEach(([key, value]) => {
+    if (slot.values[key] === defaultValues[key]) {
+      nextValues[key] = value;
+    }
+  });
+  slot.values = nextValues;
   slot.errors = validateSlot(slot, metadataSchema.value, tokenInfo.value);
 }
 

frontend/app/pages/t/[token].vue

@@ -49,4 +49,31 @@ describe('useMetadata', () => {
 
     expect(metadataSchema.value).toEqual([]);
   });
+
+  it('extracts metadata from the backend endpoint', async () => {
+    const fetchMock = mock(async () => ({ metadata: { title: 'Example Show' } }));
+    testGlobals.$fetch = fetchMock;
+    const { extractMetadata } = useMetadata();
+
+    const metadata = await extractMetadata('example.mp4');
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith('/api/metadata/extract', {
+      method: 'POST',
+      body: { filename: 'example.mp4' },
+    });
+    expect(metadata).toEqual({ title: 'Example Show' });
+  });
+
+  it('returns empty metadata when extraction fails', async () => {
+    const fetchMock = mock(async () => {
+      throw new Error('network');
+    });
+    testGlobals.$fetch = fetchMock;
+    const { extractMetadata } = useMetadata();
+
+    const metadata = await extractMetadata('example.mp4');
+
+    expect(metadata).toEqual({});
+  });
 });