HF library: auto DDA on satdetect-dev, upload to persistent storage

Dockerfile

@@ -21,7 +21,7 @@ WORKDIR /app
 
 # Build-time info + cache-bust:
 # Changing APP_BUILD forces Docker to re-run subsequent layers (including pip install).
-ARG APP_BUILD=28
+ARG APP_BUILD=29
 ENV APP_BUILD=${APP_BUILD}
 ENV GDAL_CONFIG=/usr/bin/gdal-config
 RUN echo "Docker build start: APP_BUILD=${APP_BUILD}" && python -V

app/dda/bootstrap.py

@@ -4,7 +4,7 @@ from fastapi import FastAPI
 from sqlalchemy import text as sa_text
 
 from ..database import engine
-from .config import IS_DDA_MODE, ensure_library_dirs, ensure_local_year_folders
+from .config import IS_DDA_MODE, ensure_library_dirs, ensure_local_year_folders, is_hf_hosted
 from .library_routes import router as library_router
 from .local_routes import router as local_router
 from .seed import seed_delhi_hierarchy
@@ -35,6 +35,18 @@ def init_dda_database():
     finally:
         db.close()
 
+    try:
+        from .local_library import library_debug_info, scan_images
+        info = library_debug_info()
+        logger.info(
+            "DDA library ready (hosted=%s): %d images, writable=%s",
+            is_hf_hosted(),
+            len(scan_images()),
+            info.get("roots", [{}])[0].get("path") if info.get("roots") else "?",
+        )
+    except Exception as exc:
+        logger.warning("Library scan at startup failed: %s", exc)
+
 
 def setup_dda(app: FastAPI) -> None:
     if not IS_DDA_MODE:

app/dda/config.py

@@ -4,19 +4,46 @@ from typing import List
 
 from ..database import DATA_DIR
 
-APP_MODE = os.environ.get("APP_MODE", "legacy").strip().lower()
-IS_DDA_MODE = APP_MODE == "dda"
+APP_MODE_RAW = os.environ.get("APP_MODE", "").strip().lower()
+_SPACE_ID = os.environ.get("SPACE_ID", "").strip().lower()
+
+
+def is_hf_hosted() -> bool:
+    return bool(_SPACE_ID)
+
+
+def _is_dda_mode() -> bool:
+    if APP_MODE_RAW == "legacy":
+        return False
+    if APP_MODE_RAW == "dda":
+        return True
+    # APP_MODE unset: auto-enable on satdetect-dev only (production satdetect stays legacy)
+    return _SPACE_ID.endswith("/satdetect-dev")
+
+
+IS_DDA_MODE = _is_dda_mode()
+APP_MODE = APP_MODE_RAW or ("dda" if IS_DDA_MODE else "legacy")
 
 # Project root: change_detection_webapp/
 PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
 
 
+def get_writable_library_root() -> Path:
+    """Persistent folder for uploads (HF: /home/appuser/data/library_sources)."""
+    return (DATA_DIR / "library_sources").resolve()
+
+
 def get_library_roots() -> List[Path]:
-    """All folders scanned for year-based images (project + writable data copy)."""
+    """Folders scanned for year-based images."""
     roots: List[Path] = []
     if os.environ.get("LOCAL_LIBRARY_ROOT"):
         roots.append(Path(os.environ["LOCAL_LIBRARY_ROOT"]).resolve())
-    for candidate in (PROJECT_ROOT / "library_sources", DATA_DIR / "library_sources"):
+    # Writable data dir first on Hugging Face (where uploads land)
+    if is_hf_hosted():
+        wr = get_writable_library_root()
+        if wr not in roots:
+            roots.append(wr)
+    for candidate in (get_writable_library_root(), PROJECT_ROOT / "library_sources"):
         resolved = candidate.resolve()
         if resolved not in roots:
             roots.append(resolved)

app/dda/local_routes.py

@@ -1,10 +1,19 @@
 """API for reading images from local library_sources/ year folders."""
+import logging
+from pathlib import Path
 from typing import Optional
 
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter, File, Form, HTTPException, Query, UploadFile
 from fastapi.responses import FileResponse
 
-from .config import IS_DDA_MODE, geotiff_io_available, get_library_roots
+from .config import (
+    IS_DDA_MODE,
+    geotiff_io_available,
+    get_library_roots,
+    get_writable_library_root,
+    is_hf_hosted,
+    max_upload_bytes_for_extension,
+)
 from .local_library import (
     entry_to_dict,
     get_or_build_thumb,
@@ -13,28 +22,52 @@ from .local_library import (
     scan_images,
     scan_years,
 )
+from .upload_io import stream_upload_to_file
 
+logger = logging.getLogger(__name__)
 router = APIRouter()
 
 
 def _require_dda():
     if not IS_DDA_MODE:
-        raise HTTPException(status_code=404, detail="DDA mode is not enabled on this server")
+        raise HTTPException(
+            status_code=404,
+            detail="DDA mode is not enabled. On HF dev Space this is automatic; locally use: python run.py",
+        )
+
+
+def _safe_basename(filename: str) -> str:
+    name = Path(filename or "upload").name
+    if not name or name in (".", ".."):
+        raise HTTPException(status_code=400, detail="Invalid filename")
+    return name
 
 
 @router.get("/local/config")
 def local_library_config():
     _require_dda()
     roots = [str(r) for r in get_library_roots()]
+    writable = str(get_writable_library_root())
+    hosted = is_hf_hosted()
+    if hosted:
+        instructions = (
+            "On Hugging Face, images must be uploaded below (saved to persistent storage) "
+            "or copied into the writable folder shown. Files on your PC are not visible here."
+        )
+    else:
+        instructions = (
+            "Copy .tif images into library_sources/YEAR/ in your project folder, then Refresh. "
+            "Or use Upload to save into data/library_sources/."
+        )
     return {
         "source": "local_folder",
+        "isHosted": hosted,
+        "spaceId": __import__("os").environ.get("SPACE_ID", ""),
+        "appMode": "dda" if IS_DDA_MODE else "legacy",
         "rootPath": roots[0] if roots else "",
         "rootPaths": roots,
-        "instructions": (
-            "Copy .tif / .tiff images into library_sources/YEAR/ inside the project folder "
-            "(e.g. change_detection_webapp/library_sources/2025/), then click Refresh. "
-            "Run locally with: python run.py (DDA mode is enabled automatically)."
-        ),
+        "writablePath": writable,
+        "instructions": instructions,
         "geotiffEnabled": geotiff_io_available(),
     }
 
@@ -65,11 +98,11 @@ def local_images(
 def local_image_detail(path: str = Query(..., description="Relative path e.g. 2025/aerial.tif")):
     _require_dda()
     entries = scan_images()
-    match = next((e for e in entries if e.path == path.replace("\\", "/")), None)
+    norm = path.replace("\\", "/")
+    match = next((e for e in entries if e.path == norm), None)
     if not match:
-        safe_resolve(path)  # raises 404 if missing
-        entries = scan_images()
-        match = next((e for e in entries if e.path == path.replace("\\", "/")), None)
+        safe_resolve(path)
+        match = next((e for e in scan_images() if e.path == norm), None)
     if not match:
         raise HTTPException(status_code=404, detail="Image not found in library scan")
     return entry_to_dict(match, include_meta=True)
@@ -87,9 +120,60 @@ def local_thumb(path: str = Query(...)):
         raise HTTPException(status_code=500, detail=f"Thumbnail failed: {exc}") from exc
 
 
+@router.post("/local/upload")
+async def local_upload(
+    file: UploadFile = File(...),
+    year: int = Form(...),
+):
+    """Upload GeoTIFF into persistent library_sources/YEAR/ (required on HF)."""
+    _require_dda()
+    if year < 1990 or year > 2100:
+        raise HTTPException(status_code=400, detail="year must be between 1990 and 2100")
+
+    original = _safe_basename(file.filename or "upload")
+    ext = Path(original).suffix.lower()
+    from .config import ALLOWED_EXTENSIONS
+    if ext not in ALLOWED_EXTENSIONS:
+        raise HTTPException(status_code=400, detail=f"Allowed: {', '.join(sorted(ALLOWED_EXTENSIONS))}")
+
+    root = get_writable_library_root()
+    dest = root / str(year) / original
+    if dest.exists():
+        stem = Path(original).stem
+        suffix = Path(original).suffix
+        n = 1
+        while dest.exists():
+            dest = root / str(year) / f"{stem}_{n}{suffix}"
+            n += 1
+
+    size = await stream_upload_to_file(file, dest, max_upload_bytes_for_extension(ext))
+    rel = dest.relative_to(root).as_posix()
+    logger.info("Library upload: %s (%d bytes) -> %s", original, size, dest)
+
+    entries = scan_images(year=year)
+    match = next((e for e in entries if e.path == rel or e.filename == dest.name), None)
+    if match:
+        return {"status": "success", "path": match.path, "image": entry_to_dict(match)}
+    return {
+        "status": "success",
+        "path": f"{year}/{dest.name}",
+        "fileSizeBytes": size,
+        "writablePath": str(dest),
+    }
+
+
 @router.post("/local/rescan")
 def local_rescan():
     _require_dda()
     years = scan_years()
     total = sum(y["imageCount"] for y in years)
-    return {"ok": True, "years": years, "totalImages": total, "rootPaths": [str(r) for r in get_library_roots()]}
+    info = library_debug_info()
+    logger.info("Library rescan: %d images, roots=%s", total, info.get("roots"))
+    return {
+        "ok": True,
+        "years": years,
+        "totalImages": total,
+        "rootPaths": [str(r) for r in get_library_roots()],
+        "writablePath": str(get_writable_library_root()),
+        "debug": info,
+    }

app/main.py

@@ -87,6 +87,7 @@ def health():
         "status": "ok",
         "version": "2.3.0-dda" if IS_DDA_MODE else "2.2.0",
         "appMode": "dda" if IS_DDA_MODE else "legacy",
+        "spaceId": os.environ.get("SPACE_ID", ""),
         "server_time_ist": _isoformat_ist(datetime.now(timezone.utc)),
     }
 

static/js/dda/app.js

@@ -42,6 +42,7 @@ let selectedYear = null;
 
 window.ddaState = {
   get config() { return ddaConfig; },
+  get localCfg() { return window._localCfg; },
   get years() { return localYears; },
   get selectedYear() { return selectedYear; },
   setYear(year) { selectedYear = year; },
@@ -72,16 +73,36 @@ async function initDda() {
   try {
     ddaConfig = await ddaApi('GET', '/api/dda/config');
     const localCfg = await ddaApi('GET', '/api/dda/local/config');
+    window._localCfg = localCfg;
 
     const hint = document.getElementById('lib-config-hint');
     if (hint) {
       hint.textContent = localCfg.geotiffEnabled ? 'GeoTIFF ready' : 'GeoTIFF limited';
     }
-    const paths = (localCfg.rootPaths || [localCfg.rootPath || ddaConfig.localLibraryPaths?.[0]]).filter(Boolean);
+    const paths = (localCfg.rootPaths || []).filter(Boolean);
     const pathEl = document.getElementById('lib-path-display');
-    if (pathEl) pathEl.textContent = paths.join('\n');
+    if (pathEl) {
+      pathEl.textContent = [
+        localCfg.isHosted ? 'HF writable storage:' : 'Local folders:',
+        localCfg.writablePath || paths[0] || '',
+        ...paths.filter((p) => p !== localCfg.writablePath),
+      ].filter(Boolean).join('\n');
+    }
     const folderPath = document.getElementById('lib-folder-path');
-    if (folderPath) folderPath.textContent = paths.length ? `Scanning: ${paths[0]}` : '';
+    if (folderPath) {
+      folderPath.textContent = localCfg.isHosted
+        ? 'Hugging Face — upload files below'
+        : (paths[0] ? `Scanning: ${paths[0]}` : '');
+    }
+    const instr = document.getElementById('lib-instructions');
+    if (instr && localCfg.instructions) instr.textContent = localCfg.instructions;
+
+    const hfUpload = document.getElementById('hf-upload-card');
+    if (hfUpload) hfUpload.classList.toggle('hidden', !localCfg.isHosted);
+
+    if (!localCfg.isHosted && ddaConfig.appMode !== 'dda') {
+      showDdaError('DDA mode is off. Run locally with: python run.py');
+    }
 
     const yearsData = await ddaApi('GET', '/api/dda/local/years');
     localYears = yearsData.years || [];
@@ -106,7 +127,10 @@ async function loadLibraryImages() {
   try {
     const items = await ddaApi('GET', '/api/dda/local/images?' + params.toString());
     if (!items.length) {
-      grid.innerHTML = `<p class="dim">No images in ${selectedYear || 'library_sources'}. Copy .tif files into <code>library_sources/${selectedYear || 'YEAR'}/</code> and click Refresh.</p>`;
+      const hf = window.ddaState?.localCfg?.isHosted;
+      grid.innerHTML = hf
+        ? `<p class="dim">No images on this Space yet. Use <strong>Upload to Space storage</strong> above (2025 / 2026), then click Refresh.</p>`
+        : `<p class="dim">No images in ${selectedYear || 'library_sources'}. Copy .tif files into <code>library_sources/${selectedYear || 'YEAR'}/</code> and click Refresh.</p>`;
       return;
     }
     grid.innerHTML = items.map((img) => {

static/js/dda/library.js

@@ -31,3 +31,68 @@ function renderYearTree(years) {
 document.getElementById('lib-tree-search')?.addEventListener('input', () => {
   if (window.ddaState?.years) renderYearTree(window.ddaState.years);
 });
+
+function uploadWithProgress(url, formData, onProgress) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open('POST', url);
+    xhr.withCredentials = true;
+    xhr.upload.addEventListener('progress', (e) => {
+      if (e.lengthComputable && onProgress) onProgress(e.loaded, e.total);
+    });
+    xhr.addEventListener('load', () => {
+      let data = null;
+      try { data = xhr.responseText ? JSON.parse(xhr.responseText) : null; } catch (_) {}
+      if (xhr.status >= 200 && xhr.status < 300) resolve(data);
+      else reject(new Error(data?.detail || xhr.statusText || 'Upload failed'));
+    });
+    xhr.addEventListener('error', () => reject(new Error('Network error during upload')));
+    xhr.send(formData);
+  });
+}
+
+function formatBytes(n) {
+  if (n >= 1024 ** 3) return (n / 1024 ** 3).toFixed(1) + ' GB';
+  if (n >= 1024 ** 2) return (n / 1024 ** 2).toFixed(1) + ' MB';
+  return (n / 1024).toFixed(0) + ' KB';
+}
+
+document.getElementById('form-hf-upload')?.addEventListener('submit', async (e) => {
+  e.preventDefault();
+  hideDdaError?.();
+  const fileInput = document.getElementById('hf-file');
+  const file = fileInput?.files?.[0];
+  if (!file) {
+    showDdaError?.('Select a .tif file.');
+    return;
+  }
+
+  const form = new FormData();
+  form.append('file', file);
+  form.append('year', document.getElementById('hf-year').value);
+
+  const btn = document.getElementById('btn-hf-upload');
+  const progWrap = document.getElementById('hf-upload-progress');
+  const progFill = document.getElementById('hf-upload-progress-fill');
+  const progLabel = document.getElementById('hf-upload-progress-label');
+
+  btn.disabled = true;
+  progWrap?.classList.remove('hidden');
+  if (progFill) progFill.style.width = '0%';
+
+  try {
+    await uploadWithProgress('/api/dda/local/upload', form, (loaded, total) => {
+      const pct = total ? Math.round((loaded / total) * 100) : 0;
+      if (progFill) progFill.style.width = pct + '%';
+      if (progLabel) progLabel.textContent = `Uploading… ${pct}% (${formatBytes(loaded)} / ${formatBytes(total)})`;
+    });
+    showDdaSuccess?.('Uploaded to Space library. Click Refresh if images do not appear.');
+    fileInput.value = '';
+    await window.ddaState.rescan();
+  } catch (err) {
+    showDdaError?.(err.message || 'Upload failed. Large files may exceed HF timeout — try a smaller file or run locally.');
+  } finally {
+    btn.disabled = false;
+    setTimeout(() => progWrap?.classList.add('hidden'), 2000);
+  }
+});

templates/index_dda.html

@@ -48,6 +48,30 @@
             </p>
             <pre id="lib-path-display" class="dda-path-code"></pre>
           </div>
+          <div class="card hidden" id="hf-upload-card">
+            <div class="card-header">
+              <h3>Upload to Space storage</h3>
+              <span class="dim">Required on Hugging Face</span>
+            </div>
+            <p class="sub">Files on your computer are not on the server. Upload .tif images here (up to 2 GB each).</p>
+            <form id="form-hf-upload" class="dda-upload-form">
+              <div class="location-row">
+                <div class="form-group">
+                  <label for="hf-year">Year folder</label>
+                  <input type="number" id="hf-year" required min="2000" max="2100" value="2025" />
+                </div>
+                <div class="form-group">
+                  <label for="hf-file">GeoTIFF file</label>
+                  <input type="file" id="hf-file" accept=".tif,.tiff" required />
+                </div>
+              </div>
+              <div id="hf-upload-progress" class="dda-upload-progress hidden">
+                <div class="dda-progress-bar"><div id="hf-upload-progress-fill" class="dda-progress-fill"></div></div>
+                <span id="hf-upload-progress-label" class="dim">Uploading…</span>
+              </div>
+              <button type="submit" class="btn btn-primary" id="btn-hf-upload">Upload to library</button>
+            </form>
+          </div>
           <div class="card">
             <div class="card-header">
               <h3 id="lib-grid-title">Images</h3>
@@ -88,7 +112,7 @@
     </section>
   </div>
 
-  <script src="/static/js/dda/app.js?v=4"></script>
-  <script src="/static/js/dda/library.js?v=4"></script>
+  <script src="/static/js/dda/app.js?v=5"></script>
+  <script src="/static/js/dda/library.js?v=5"></script>
 </body>
 </html>