-

Author: alexh-scrt

dockerize/Dockerfile

@@ -50,6 +50,8 @@ USER model-server
 
 # Create necessary directories
 RUN mkdir -p logs temp model-store
+RUN mkdir -p worspace/input
+RUN mkdir -p workspace/output
 
 # Set environment variables
 ENV PYTHONUNBUFFERED=1
@@ -67,8 +69,8 @@ ENV TS_LOG_LOCATION=/home/model-server/logs
 ENV TS_METRICS_LOCATION=/home/model-server/logs
 
 # Security: Ensure API keys are provided via environment variables
-ENV OPENAI_API_KEY=""
-ENV PERPLEXITY_API_KEY=""
+ENV OPENAI_API_KEY="sk-proj-0czRbrIbGA26Ds8ePR3KT3BlbkFJpgq1SoqNiM5LGtwU0Gts"
+ENV PERPLEXITY_API_KEY="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"
 ENV GOOGLE_APPLICATION_CREDENTIALS="dummy-key"
 ENV LOCAL_EXECUTION=True
 # Expose TorchServe ports

dockerize/docker-compose.yaml

@@ -47,6 +47,8 @@ services:
       - ./config/config-docker.properties:/home/model-server/config/config-docker.properties:ro
       # Share point for keys
       - torchserve-tokens:/home/model-server
+      # Input/Output exchange
+      - shared-workspace:/home/model-server/workspace:rw
 
     # Memory and shared memory settings for deep learning
     shm_size: 2gb
@@ -119,6 +121,7 @@ services:
 
     volumes:
       - torchserve-tokens:/app/tokens:ro
+      - shared-workspace:/app/workspace:rw
 
 # Networks
 networks:
@@ -130,4 +133,6 @@ volumes:
   temp:
     driver: local
   torchserve-tokens:
+    driver: local
+  shared-workspace:
     driver: local

dockerize/request.json

@@ -6,10 +6,10 @@
     "shape": [1],
     "data": [{
       "bucket": "not_needed",
-      "root_path": "/home/model-server/temp",
+      "root_path": "/home/model-server/workspace",
       "input_folder": "input",
       "output_folder": "output", 
-      "input_files": ["/home/ubuntu/workspace/secret-ai-fetch/examples/input/sample_A1.jpg"]
+      "input_files": ["sample_A1.jpg"]
     }]
   }]
 }

dockerize/secretai/Dockerfile

@@ -10,6 +10,9 @@ LABEL version="1.0"
 # Set working directory
 WORKDIR /app
 RUN mkdir -p /app/tokens
+RUN mkdir -p worspace/input
+RUN mkdir -p workspace/output
+
 # Install system dependencies
 RUN apt-get update && apt-get install -y \
     curl \

dockerize/secretai/build-info.json

@@ -1,8 +1,8 @@
 {
-    "build_time": "2025-06-24T23:49:59Z",
+    "build_time": "2025-06-25T02:47:42Z",
     "image_name": "monai-secretai",
     "image_tag": "dev",
-    "git_commit": "04413f4a302cffd6724910aca12083d8b6c3e0ec",
+    "git_commit": "c2a66210ce488e7d459c47889a2e71ee42d221c3",
     "git_branch": "master",
     "platform": "",
     "builder": "ubuntu@158-101-123-7"

dockerize/secretai/server.py

@@ -10,10 +10,13 @@
 import httpx
 import json
 import re
+import uuid
+import shutil
 from datetime import datetime
 from typing import Optional, Dict, Any
+from pathlib import Path
 
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, UploadFile, File
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from contextlib import asynccontextmanager
@@ -47,6 +50,11 @@
 # Global flag to track if tokens are ready
 tokens_ready = False
 
+# Workspace paths for file management
+WORKSPACE_PATH = Path("/app/workspace")
+INPUTS_PATH = WORKSPACE_PATH / "input"  # Note: singular "input" to match your JSON
+OUTPUTS_PATH = WORKSPACE_PATH / "output"  # Note: singular "output" to match your JSON
+
 # Enhanced endpoint to token type mapping using regex patterns
 ENDPOINT_TOKEN_MAPPING = {
     # Management API endpoints
@@ -196,7 +204,6 @@ async def wait_for_torchserve_tokens():
         print("🚀 Continuing startup - some TorchServe features may be unavailable")
         return False
 
-# Startup/Shutdown Events
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     # Startup
@@ -208,6 +215,15 @@ async def lifespan(app: FastAPI):
     print(f"🎯 TorchServe Management URL: {TORCHSERVE_MANAGEMENT_URL}")
     print(f"📂 Token file path: {torchserve_tokens.tokens_file_path}")
     print("🔓 Open access - no authentication required")
+    
+    # Create workspace directories
+    WORKSPACE_PATH.mkdir(exist_ok=True)
+    INPUTS_PATH.mkdir(exist_ok=True)
+    OUTPUTS_PATH.mkdir(exist_ok=True)
+    
+    print(f"📁 Workspace: {WORKSPACE_PATH}")
+    print(f"📥 Input folder: {INPUTS_PATH}")
+    print(f"📤 Output folder: {OUTPUTS_PATH}")
     print("=" * 60)
 
     # Wait for TorchServe tokens
@@ -374,43 +390,91 @@ async def model_info_alias(model_name: str):
     return await torchserve_model_info(model_name)
 
 @app.post("/predict/breast-density")
-async def predict_breast_density(request: Request):
+async def predict_breast_density(file: UploadFile = File(...)):
     """
-    Proxy inference request to TorchServe breast density model - Uses inference token
+    Upload image file and make breast density prediction
+    
+    Process:
+    1. Save uploaded file to /app/workspace/input
+    2. Generate JSON payload for TorchServe
+    3. Forward request to TorchServe
+    4. Return TorchServe response to caller
     """
     try:
-        # Get request body
-        body = await request.body()
+        # Generate unique UUID for this request
+        unique_id = str(uuid.uuid4())
 
-        # Get content type
-        content_type = request.headers.get("content-type")
+        # Validate file type
+        if not file.content_type or not file.content_type.startswith('image/'):
+            raise HTTPException(status_code=400, detail="File must be an image")
+        
+        # Create workspace directories if they don't exist
+        WORKSPACE_PATH.mkdir(exist_ok=True)
+        INPUTS_PATH.mkdir(exist_ok=True)
+        OUTPUTS_PATH.mkdir(exist_ok=True)
+        
+        # Save uploaded file to /app/workspace/input with original filename
+        input_file_path = INPUTS_PATH / file.filename
+        
+        print(f"💾 Saving uploaded file: {file.filename} to {input_file_path}")
+        
+        # Save the uploaded file
+        with open(input_file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        print(f"✅ File saved successfully: {input_file_path}")
+        
+        # Prepare JSON payload for TorchServe
+        torchserve_payload = {
+            "id": unique_id,
+            "inputs": [{
+                "name": "data",
+                "datatype": "json",
+                "shape": [1],
+                "data": [{
+                    "bucket": "not_needed",
+                    "root_path": "/home/model-server/workspace",
+                    "input_folder": "input",
+                    "output_folder": "output",
+                    "input_files": [file.filename]
+                }]
+            }]
+        }
+        
+        print(f"🔮 Making prediction request with UUID: {unique_id}")
+        print(f"📋 Payload: {json.dumps(torchserve_payload, indent=2)}")
 
         # Forward request to TorchServe with retry logic
         response = await request_with_token_retry(
             f"{TORCHSERVE_URL}/predictions/breast-density",
             method="POST",
             endpoint_path="/predictions/breast-density",
-            content=body,
-            headers={"Content-Type": content_type} if content_type else {}
+            json=torchserve_payload,
+            headers={"Content-Type": "application/json"}
         )
 
-        # Return response
+        print(f"📤 TorchServe response status: {response.status_code}")
+        
+        # Parse and return TorchServe response
         if response.headers.get("content-type", "").startswith("application/json"):
             content = response.json()
+            print(f"📄 TorchServe JSON response: {json.dumps(content, indent=2)}")
         else:
             content = {"result": response.text}
+            print(f"📄 TorchServe text response: {response.text}")
 
         return JSONResponse(content=content, status_code=response.status_code)
 
     except HTTPException:
         raise
     except Exception as e:
+        print(f"❌ Prediction failed: {str(e)}")
         raise HTTPException(status_code=503, detail=f"TorchServe unavailable: {str(e)}")
 
-@app.post("/predictions/{model_name}")
-async def predict_generic(model_name: str, request: Request):
+@app.post("/predict/breast-density-json")
+async def predict_breast_density_json(request: Request):
     """
-    Generic prediction endpoint for any model - Uses inference token
+    Alternative endpoint for JSON-based prediction (for backward compatibility)
     """
     try:
         # Get request body
@@ -419,28 +483,79 @@ async def predict_generic(model_name: str, request: Request):
         # Get content type
         content_type = request.headers.get("content-type")
 
+        print(f"📋 Received JSON prediction request")
+        print(f"📄 Payload: {body.decode('utf-8')}")
+        
         # Forward request to TorchServe with retry logic
         response = await request_with_token_retry(
-            f"{TORCHSERVE_URL}/predictions/{model_name}",
+            f"{TORCHSERVE_URL}/predictions/breast-density",
             method="POST",
-            endpoint_path=f"/predictions/{model_name}",
+            endpoint_path="/predictions/breast-density",
             content=body,
             headers={"Content-Type": content_type} if content_type else {}
         )
 
+        print(f"📤 TorchServe response status: {response.status_code}")
+        
         # Return response
         if response.headers.get("content-type", "").startswith("application/json"):
             content = response.json()
+            print(f"📄 TorchServe JSON response: {json.dumps(content, indent=2)}")
         else:
             content = {"result": response.text}
+            print(f"📄 TorchServe text response: {response.text}")
 
         return JSONResponse(content=content, status_code=response.status_code)
 
     except HTTPException:
         raise
     except Exception as e:
+        print(f"❌ JSON prediction failed: {str(e)}")
         raise HTTPException(status_code=503, detail=f"TorchServe unavailable: {str(e)}")
 
+@app.get("/workspace/files")
+async def list_workspace_files():
+    """
+    List files in the workspace directories
+    """
+    try:
+        input_files = [f.name for f in INPUTS_PATH.iterdir() if f.is_file()] if INPUTS_PATH.exists() else []
+        output_files = [f.name for f in OUTPUTS_PATH.iterdir() if f.is_file()] if OUTPUTS_PATH.exists() else []
+        
+        return {
+            "workspace": str(WORKSPACE_PATH),
+            "input_folder": str(INPUTS_PATH),
+            "output_folder": str(OUTPUTS_PATH),
+            "input_files": input_files,
+            "output_files": output_files,
+            "total_input_files": len(input_files),
+            "total_output_files": len(output_files)
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to list workspace files: {str(e)}")
+
+@app.get("/workspace/status")
+async def workspace_status():
+    """
+    Get workspace status and directory information
+    """
+    try:
+        return {
+            "workspace_path": str(WORKSPACE_PATH),
+            "workspace_exists": WORKSPACE_PATH.exists(),
+            "input_path": str(INPUTS_PATH),
+            "input_exists": INPUTS_PATH.exists(),
+            "output_path": str(OUTPUTS_PATH),
+            "output_exists": OUTPUTS_PATH.exists(),
+            "permissions": {
+                "workspace_writable": os.access(WORKSPACE_PATH, os.W_OK) if WORKSPACE_PATH.exists() else False,
+                "input_writable": os.access(INPUTS_PATH, os.W_OK) if INPUTS_PATH.exists() else False,
+                "output_readable": os.access(OUTPUTS_PATH, os.R_OK) if OUTPUTS_PATH.exists() else False
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to get workspace status: {str(e)}")
+
 @app.get("/torchserve/metrics")
 async def torchserve_metrics():
     """
@@ -540,29 +655,45 @@ async def root():
     return {
         "service": "MONAI Gateway Service",
         "version": "1.0.0",
-        "description": "Open gateway for MONAI Breast Density Classification",
+        "description": "Open gateway for MONAI Breast Density Classification with file upload support",
         "access_mode": "open",
         "authentication": "disabled",
         "endpoints": {
+            "prediction": {
+                "upload_and_predict": "POST /predict/breast-density (multipart/form-data with file)",
+                "json_predict": "POST /predict/breast-density-json (application/json)",
+                "description": "Upload image file or send JSON payload for breast density analysis"
+            },
+            "workspace": {
+                "list_files": "GET /workspace/files",
+                "status": "GET /workspace/status",
+                "description": "Manage and monitor workspace files"
+            },
             "torchserve": {
-                "ping": "/ping or /torchserve/ping",
-                "models": "/models or /torchserve/models",
-                "model_info": "/models/{model_name} or /torchserve/models/{model_name}",
-                "predict_breast_density": "/predict/breast-density",
-                "predict_generic": "/predictions/{model_name}",
-                "metrics": "/metrics or /torchserve/metrics",
-                "token_info": "/torchserve/token-info"
+                "ping": "GET /ping or /torchserve/ping",
+                "models": "GET /models or /torchserve/models",
+                "model_info": "GET /models/{model_name} or /torchserve/models/{model_name}",
+                "metrics": "GET /metrics or /torchserve/metrics",
+                "token_info": "GET /torchserve/token-info"
             },
             "system": {
-                "health": "/health",
-                "docs": "/docs",
-                "root": "/"
+                "health": "GET /health",
+                "docs": "GET /docs",
+                "root": "GET /"
             }
         },
+        "usage_example": {
+            "curl_upload": "curl -X POST -F \"[email protected]\" http://localhost:8090/predict/breast-density",
+            "curl_json": "curl -X POST -H \"Content-Type: application/json\" -d '{\"id\":\"test\",\"inputs\":[...]}' http://localhost:8090/predict/breast-density-json"
+        },
+        "workspace": {
+            "input_path": str(INPUTS_PATH),
+            "output_path": str(OUTPUTS_PATH),
+            "note": "Uploaded files are saved to input folder, results are written to output folder"
+        },
         "tokens_ready": tokens_ready,
         "endpoint_mappings": ENDPOINT_TOKEN_MAPPING,
-        "torchserve_url": TORCHSERVE_URL,
-        "note": "All endpoints are accessible without authentication"
+        "torchserve_url": TORCHSERVE_URL
     }
 
 # Error Handlers