file uploading fixed

Author: akgohain

client/src/components/Dragger.js

@@ -8,8 +8,38 @@ import UTIF from 'utif'
 
 const path = require('path')
 
+const ensureTrailingSeparator = (dirPath) => {
+  if (!dirPath) return ''
+  return dirPath.endsWith(path.sep) ? dirPath : dirPath + path.sep
+}
+
+const getFolderPath = (uploadFile, originPath) => {
+  if (uploadFile?.folderPath) {
+    return ensureTrailingSeparator(uploadFile.folderPath)
+  }
+  if (!originPath) return ''
+  return ensureTrailingSeparator(path.dirname(originPath))
+}
+
+const enrichFileMetadata = (uploadFile) => {
+  const originPath =
+    uploadFile?.originFileObj?.path ||
+    uploadFile?.path
+  const folderPath = getFolderPath(uploadFile, originPath)
+
+  const enhancedFile = { ...uploadFile }
+  if (originPath) {
+    enhancedFile.path = originPath
+  }
+  if (folderPath) {
+    enhancedFile.folderPath = folderPath
+  }
+  return enhancedFile
+}
+
 export function Dragger () {
   const context = useContext(AppContext)
+  const { setFiles, files } = context
 
   // const getBase64 = (file) =>
   //   new Promise((resolve, reject) => {
@@ -22,22 +52,21 @@ export function Dragger () {
   const onChange = (info) => {
     const { status } = info.file
     if (status === 'done') {
-      console.log('file found at:', info.file.originFileObj.path)
+      const originPath =
+        info.file?.originFileObj?.path ||
+        info.file?.path
+      console.log('file found at:', originPath)
 
       message.success(`${info.file.name} file uploaded successfully.`)
-      if (window.require) {
-        const modifiedFile = { ...info.file, path: info.file.originFileObj.path }
-        context.setFiles([...context.files, modifiedFile])
-      } else {
-        context.setFiles([...info.fileList])
-      }
+      const updatedFiles = info.fileList.map(enrichFileMetadata)
+      setFiles(updatedFiles)
       console.log('done')
     } else if (status === 'error') {
       console.log('error')
       message.error(`${info.file.name} file upload failed.`)
     } else if (status === 'removed') {
       console.log(info.fileList)
-      context.setFiles([...info.fileList])
+      setFiles(info.fileList.map(enrichFileMetadata))
     }
   }
 
@@ -58,6 +87,22 @@ export function Dragger () {
   const [previewFileFolderPath, setPreviewFileFolderPath] = useState('')
   const [fileType, setFileType] = useState('Image')
 
+  useEffect(() => {
+    if (!files || files.length === 0) return
+    const needsFolderPath = files.some(
+      (file) =>
+        !file.folderPath &&
+        (file?.originFileObj?.path || file?.path)
+    )
+    if (needsFolderPath) {
+      setFiles(
+        files.map((file) =>
+          !file.folderPath ? enrichFileMetadata(file) : file
+        )
+      )
+    }
+  }, [files, setFiles])
+
   const handleText = (event) => {
     setValue(event.target.value)
   }
@@ -177,8 +222,12 @@ export function Dragger () {
           .folderPath
       )
     } else {
-      // Directory name with trailing slash
-      setPreviewFileFolderPath(path.dirname(file.originFileObj.path) + '/')
+      const originPath =
+        file?.originFileObj?.path ||
+        file?.path
+      setPreviewFileFolderPath(
+        originPath ? ensureTrailingSeparator(path.dirname(originPath)) : ''
+      )
     }
   }
 

client/src/utils/api.js

@@ -5,17 +5,47 @@ import { message } from 'antd'
 const API_PROTOCOL = process.env.REACT_APP_API_PROTOCOL || 'http'
 const API_URL = process.env.REACT_APP_API_URL || 'localhost:4242'
 
+const buildFilePath = (file) => {
+  if (!file) return ''
+  if (file.folderPath) return file.folderPath + file.name
+  if (file.path) return file.path
+  if (file.originFileObj && file.originFileObj.path) {
+    return file.originFileObj.path
+  }
+  return file.name
+}
+
+const hasBrowserFile = (file) =>
+  file && file.originFileObj instanceof File
+
 export async function getNeuroglancerViewer (image, label, scales) {
   try {
+    const url = `${API_PROTOCOL}://${API_URL}/neuroglancer`
+    if (hasBrowserFile(image)) {
+      const formData = new FormData()
+      formData.append(
+        'image',
+        image.originFileObj,
+        image.originFileObj.name || image.name || 'image'
+      )
+      if (label && hasBrowserFile(label)) {
+        formData.append(
+          'label',
+          label.originFileObj,
+          label.originFileObj.name || label.name || 'label'
+        )
+      }
+      formData.append('scales', JSON.stringify(scales))
+      const res = await axios.post(url, formData)
+      return res.data
+    }
+
     const data = JSON.stringify({
-      image: image.folderPath + image.name,
-      label: label.folderPath + label.name,
+      image: buildFilePath(image),
+      label: buildFilePath(label),
       scales
     })
-    const res = await axios.post(
-      `${API_PROTOCOL}://${API_URL}/neuroglancer`,
-      data
-    )
+    const res = await axios.post(url, data)
     return res.data
   } catch (error) {
     message.error(

server_api/main.py

@@ -1,8 +1,12 @@
+import json
 import pathlib
+import shutil
+import tempfile
+from typing import List, Optional
 
 import requests
 import uvicorn
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, HTTPException, Request, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
 from utils.io import readVol
 
@@ -21,11 +25,21 @@
 
 
 def process_path(path):
-    # Get the absolute path of the current script"s parent directory
-    current_script_dir = pathlib.Path(__file__).parent
-    # The root of the repository is assumed to be one level up from the current script"s directory
-    repo_root = current_script_dir.parent.absolute()
-    return repo_root / path
+    if not path:
+        return None
+    candidate = pathlib.Path(path).expanduser()
+    if candidate.is_absolute():
+        return candidate
+    return candidate.resolve(strict=False)
+
+
+def save_upload_to_tempfile(upload: UploadFile) -> pathlib.Path:
+    suffix = pathlib.Path(upload.filename or "").suffix
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+        upload.file.seek(0)
+        shutil.copyfileobj(upload.file, tmp)
+        temp_path = pathlib.Path(tmp.name)
+    return temp_path
 
 
 @app.get("/hello")
@@ -37,35 +51,73 @@ def hello():
 async def neuroglancer(req: Request):
     import neuroglancer
 
-    req = await req.json()
-    image = process_path(req["image"])
-    label = process_path(req["label"])
-    scales = req["scales"]
-    print(image, label, scales)
-    # neuroglancer setting -- bind to this to make accessible outside of container
-    ip = "0.0.0.0"
-    port = 4244
-    neuroglancer.set_server_bind_address(ip, port)
-    viewer = neuroglancer.Viewer()
-    # SNEMI (# 3d vol dim: z,y,x)
-    res = neuroglancer.CoordinateSpace(
-        names=["z", "y", "x"], units=["nm", "nm", "nm"], scales=scales
-    )
-    im = readVol(image, image_type="im")
-    gt = readVol(label, image_type="im")
-
-    def ngLayer(data, res, oo=[0, 0, 0], tt="segmentation"):
-        return neuroglancer.LocalVolume(
-            data, dimensions=res, volume_type=tt, voxel_offset=oo
+    cleanup_paths: List[pathlib.Path] = []
+    try:
+        content_type = req.headers.get("content-type", "")
+        if "multipart/form-data" in content_type:
+            form = await req.form()
+            image_upload = form.get("image")
+            if not image_upload or not getattr(image_upload, "filename", None):
+                raise HTTPException(status_code=400, detail="Image file is required.")
+            scales_raw = form.get("scales")
+            if scales_raw is None:
+                raise HTTPException(status_code=400, detail="Scales are required.")
+            try:
+                scales = json.loads(scales_raw)
+            except json.JSONDecodeError:
+                raise HTTPException(status_code=400, detail="Scales payload is invalid.")
+
+            image = save_upload_to_tempfile(image_upload)
+            cleanup_paths.append(image)
+
+            label_upload = form.get("label")
+            label: Optional[pathlib.Path] = None
+            if label_upload and getattr(label_upload, "filename", None):
+                label = save_upload_to_tempfile(label_upload)
+                cleanup_paths.append(label)
+        else:
+            payload = await req.json()
+            image = process_path(payload["image"])
+            label = process_path(payload.get("label"))
+            scales = payload["scales"]
+
+        print(image, label, scales)
+
+        if image is None:
+            raise HTTPException(status_code=400, detail="Image path or file is required.")
+
+        # neuroglancer setting -- bind to this to make accessible outside of container
+        ip = "0.0.0.0"
+        port = 4244
+        neuroglancer.set_server_bind_address(ip, port)
+        viewer = neuroglancer.Viewer()
+        # SNEMI (# 3d vol dim: z,y,x)
+        res = neuroglancer.CoordinateSpace(
+            names=["z", "y", "x"], units=["nm", "nm", "nm"], scales=scales
         )
-
-    with viewer.txn() as s:
-        s.layers.append(name="im", layer=ngLayer(im, res, tt="image"))
-        if label:
-            s.layers.append(name="gt", layer=ngLayer(gt, res, tt="segmentation"))
-
-    print(viewer)
-    return str(viewer)
+        im = readVol(image, image_type="im")
+        gt = readVol(label, image_type="im") if label else None
+
+        def ngLayer(data, res, oo=[0, 0, 0], tt="segmentation"):
+            return neuroglancer.LocalVolume(
+                data, dimensions=res, volume_type=tt, voxel_offset=oo
+            )
+
+        with viewer.txn() as s:
+            s.layers.append(name="im", layer=ngLayer(im, res, tt="image"))
+            if gt is not None:
+                s.layers.append(name="gt", layer=ngLayer(gt, res, tt="segmentation"))
+
+        print(viewer)
+        return str(viewer)
+    finally:
+        for path in cleanup_paths:
+            try:
+                path.unlink()
+            except FileNotFoundError:
+                pass
+            except PermissionError:
+                pass
 
 
 @app.post("/start_model_training")

tests/api.py

@@ -1,8 +1,68 @@
+import io
+import json
+import sys
+
 import httpx
 import pytest
+import numpy as np
 from fastapi import FastAPI
 from httpx import AsyncClient
 from server_api.main import app as fastapi_app
+from types import SimpleNamespace
+
+
+class DummyLayers(list):
+    def append(self, name=None, layer=None):  # type: ignore[override]
+        super().append({"name": name, "layer": layer})
+
+
+class DummyTxn:
+    def __init__(self, viewer):
+        self.viewer = viewer
+
+    def __enter__(self):
+        return SimpleNamespace(layers=self.viewer.layers)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+
+class DummyViewer:
+    def __init__(self):
+        self.layers = DummyLayers()
+
+    def txn(self):
+        return DummyTxn(self)
+
+    def __str__(self):
+        return "dummy_viewer"
+
+
+class DummyCoordinateSpace:
+    def __init__(self, names, units, scales):
+        self.names = names
+        self.units = units
+        self.scales = scales
+
+
+class DummyLocalVolume:
+    def __init__(self, data, dimensions, volume_type, voxel_offset):
+        self.data = data
+        self.dimensions = dimensions
+        self.volume_type = volume_type
+        self.voxel_offset = voxel_offset
+
+
+@pytest.fixture(autouse=True)
+def stub_neuroglancer(monkeypatch):
+    dummy_module = SimpleNamespace(
+        set_server_bind_address=lambda ip, port: None,
+        Viewer=DummyViewer,
+        CoordinateSpace=DummyCoordinateSpace,
+        LocalVolume=DummyLocalVolume,
+    )
+    monkeypatch.setitem(sys.modules, "neuroglancer", dummy_module)
+    yield
 
 
 @pytest.fixture
@@ -25,8 +85,22 @@ async def test_hello(client: AsyncClient) -> None:
 
 @pytest.mark.asyncio
 async def test_neuroglancer(client: AsyncClient) -> None:
-    data = {"image": "test_image", "label": "test_label", "scales": [4, 4, 4]}
-    # The actual testing of this route may need to be adjusted based on your actual functionality.
-    # You might need to mock calls to `neuroglancer` or other external libraries.
-    response = await client.post("/neuroglancer", json=data)
+    array = np.zeros((2, 2), dtype=np.uint8)
+    image_buffer = io.BytesIO()
+    label_buffer = io.BytesIO()
+    np.save(image_buffer, array)
+    np.save(label_buffer, array)
+    image_buffer.seek(0)
+    label_buffer.seek(0)
+
+    files = {
+        "image": ("image.npy", image_buffer, "application/octet-stream"),
+        "label": ("label.npy", label_buffer, "application/octet-stream"),
+    }
+
+    response = await client.post(
+        "/neuroglancer",
+        data={"scales": json.dumps([4, 4, 4])},
+        files=files,
+    )
     assert response.status_code == 200