commit 2

README.md

@@ -21,15 +21,12 @@ This is a FastAPI service that uses HuggingFace's proven segment-based classific
 - **Dual Criteria Generation**: Creates two different highlight criteria sets and selects the most selective one
 - **SmolVLM2-256M-Video-Instruct**: Faster processing with specialized video understanding
 - **Visual Effects**: Optional fade transitions between segments for professional-quality output
-- **REST API**: Upload videos and download processed highlights with job tracking
-- **Background Processing**: Non-blocking video processing with real-time status updates
+- **REST API**: Upload videos and get generated video description + analysis file path
 
 ## 🔗 API Endpoints
 
-- `POST /upload-video` - Upload video for processing
-- `GET /job-status/{job_id}` - Check processing status
-- `GET /download/{filename}` - Download generated highlights
-- `GET /docs` - Interactive API documentation
+- `POST /upload-video` - Upload video and receive analysis response
+- `GET /health` - Health check
 
 ## 📱 Usage
 
@@ -42,13 +39,16 @@ curl -X POST \
   -F "model_name=HuggingFaceTB/SmolVLM2-256M-Video-Instruct" \
   -F "with_effects=true" \
   https://your-space-url.hf.space/upload-video
+```
 
-# Check processing status
-curl https://your-space-url.hf.space/job-status/YOUR_JOB_ID
-
-# Download highlights and analysis
-curl -O https://your-space-url.hf.space/download/HIGHLIGHTS.mp4
-curl -O https://your-space-url.hf.space/download/ANALYSIS.json
+Example response:
+```json
+{
+  "success": true,
+  "message": "Video description generated successfully",
+  "video_description": "A concise description of the uploaded video...",
+  "analysis_file": "/tmp/outputs/<uuid>_analysis.json"
+}
 ```
 
 ### Via Android App

app.py

@@ -5,7 +5,6 @@ Updated with the latest segment-based approach for better accuracy
 """
 
 import os
-import tempfile
 
 # Set cache directories to writable locations for HuggingFace Spaces
 # Use /tmp which is guaranteed to be writable in containers
@@ -20,17 +19,13 @@ os.environ['XDG_CACHE_HOME'] = os.path.join("/tmp", ".cache")
 os.environ['HUGGINGFACE_HUB_CACHE'] = CACHE_DIR
 os.environ['TOKENIZERS_PARALLELISM'] = 'false'
 
-from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks
-from fastapi.responses import FileResponse, JSONResponse
+from fastapi import FastAPI, UploadFile, File, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import sys
 import uuid
 import json
-import asyncio
 from pathlib import Path
-from typing import Optional
-import logging
 
 # Add src directory to path for imports
 sys.path.append(str(Path(__file__).parent / "src"))
@@ -41,15 +36,14 @@ except ImportError:
     print("❌ Cannot import huggingface_exact_approach.py")
     sys.exit(1)
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
 # FastAPI app
 app = FastAPI(
     title="SmolVLM2 Optimized HuggingFace Video Highlights API",
     description="Generate intelligent video highlights using SmolVLM2 segment-based approach",
-    version="2.0.0"
+    version="2.0.0",
+    openapi_url=None,
+    docs_url=None,
+    redoc_url=None
 )
 
 # Enable CORS for web apps
@@ -61,31 +55,11 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Request/Response models
-class AnalysisRequest(BaseModel):
-    segment_length: float = 5.0
-    model_name: str = "HuggingFaceTB/SmolVLM2-256M-Video-Instruct"
-    with_effects: bool = True
-
 class AnalysisResponse(BaseModel):
-    job_id: str
-    status: str
+    success: bool
     message: str
-
-class JobStatus(BaseModel):
-    job_id: str
-    status: str  # "processing", "completed", "failed"
-    progress: int  # 0-100
-    message: str
-    highlights_url: Optional[str] = None
-    analysis_url: Optional[str] = None
-    total_segments: Optional[int] = None
-    selected_segments: Optional[int] = None
-    compression_ratio: Optional[float] = None
-
-# Global storage for jobs (in production, use Redis/database)
-active_jobs = {}
-completed_jobs = {}
+    video_description: str
+    analysis_file: str
 
 # Create output directories with proper permissions
 TEMP_DIR = os.path.join("/tmp", "temp")
@@ -95,100 +69,13 @@ OUTPUTS_DIR = os.path.join("/tmp", "outputs")
 os.makedirs(OUTPUTS_DIR, mode=0o755, exist_ok=True)
 os.makedirs(TEMP_DIR, mode=0o755, exist_ok=True)
 
-@app.get("/")
-async def read_root():
-    """Welcome message with API information"""
-    return {
-        "message": "SmolVLM2 Optimized HuggingFace Video Highlights API",
-        "version": "3.0.0",
-        "approach": "Optimized HuggingFace exact approach with STRICT prompting",
-        "model": "SmolVLM2-256M-Video-Instruct (faster processing)",
-        "improvements": [
-            "STRICT system prompting for selectivity",
-            "Structured YES/NO user prompts", 
-            "Temperature 0.3 for consistent decisions",
-            "Enhanced response processing with fallbacks"
-        ],
-        "endpoints": {
-            "upload": "POST /upload-video",
-            "status": "GET /job-status/{job_id}",
-            "download": "GET /download/{filename}",
-            "docs": "GET /docs"
-        }
-    }
-
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""
     return {"status": "healthy", "model": "SmolVLM2-256M-Video-Instruct"}
 
-async def process_video_background(job_id: str, video_path: str, output_path: str, 
-                                 segment_length: float, model_name: str, with_effects: bool):
-    """Background task to process video"""
-    try:
-        # Update job status
-        active_jobs[job_id]["status"] = "processing"
-        active_jobs[job_id]["progress"] = 10
-        active_jobs[job_id]["message"] = "Initializing AI model..."
-        
-        # Initialize detector
-        detector = VideoHighlightDetector(model_path=model_name)
-        
-        active_jobs[job_id]["progress"] = 20
-        active_jobs[job_id]["message"] = "Analyzing video content..."
-        
-        # Process video
-        results = detector.process_video(
-            video_path=video_path,
-            output_path=output_path,
-            segment_length=segment_length,
-            with_effects=with_effects
-        )
-        
-        if "error" in results:
-            # Failed
-            active_jobs[job_id]["status"] = "failed"
-            active_jobs[job_id]["message"] = results["error"]
-            active_jobs[job_id]["progress"] = 0
-        else:
-            # Success - move to completed jobs
-            output_filename = os.path.basename(output_path)
-            analysis_filename = output_filename.replace('.mp4', '_analysis.json')
-            analysis_path = os.path.join(OUTPUTS_DIR, analysis_filename)
-            
-            # Save analysis
-            with open(analysis_path, 'w') as f:
-                json.dump(results, f, indent=2)
-            
-            completed_jobs[job_id] = {
-                "job_id": job_id,
-                "status": "completed",
-                "progress": 100,
-                "message": f"Created highlights with {results['selected_segments']} segments",
-                "highlights_url": f"/download/{output_filename}",
-                "analysis_url": f"/download/{analysis_filename}",
-                "total_segments": results["total_segments"],
-                "selected_segments": results["selected_segments"],
-                "compression_ratio": results["compression_ratio"]
-            }
-            
-            # Remove from active jobs
-            if job_id in active_jobs:
-                del active_jobs[job_id]
-                
-    except Exception as e:
-        logger.error(f"Error processing video {job_id}: {str(e)}")
-        active_jobs[job_id]["status"] = "failed"
-        active_jobs[job_id]["message"] = f"Processing error: {str(e)}"
-        active_jobs[job_id]["progress"] = 0
-    finally:
-        # Clean up temp video file
-        if os.path.exists(video_path):
-            os.unlink(video_path)
-
 @app.post("/upload-video", response_model=AnalysisResponse)
 async def upload_video(
-    background_tasks: BackgroundTasks,
     video: UploadFile = File(...),
     segment_length: float = 5.0,
     model_name: str = "HuggingFaceTB/SmolVLM2-256M-Video-Instruct",
@@ -207,126 +94,45 @@ async def upload_video(
     if not video.content_type.startswith('video/'):
         raise HTTPException(status_code=400, detail="File must be a video")
     
-    # Generate unique job ID
-    job_id = str(uuid.uuid4())
-    
     # Save uploaded video to temp file
+    job_id = str(uuid.uuid4())
     temp_video_path = os.path.join(TEMP_DIR, f"{job_id}_input.mp4")
     output_path = os.path.join(OUTPUTS_DIR, f"{job_id}_highlights.mp4")
+    analysis_path = os.path.join(OUTPUTS_DIR, f"{job_id}_analysis.json")
     
     try:
         # Save uploaded file
         with open(temp_video_path, "wb") as buffer:
             content = await video.read()
             buffer.write(content)
-        
-        # Initialize job tracking
-        active_jobs[job_id] = {
-            "job_id": job_id,
-            "status": "queued",
-            "progress": 5,
-            "message": "Video uploaded, queued for processing",
-            "highlights_url": None,
-            "analysis_url": None
-        }
-        
-        # Start background processing
-        background_tasks.add_task(
-            process_video_background,
-            job_id, temp_video_path, output_path, 
-            segment_length, model_name, with_effects
+
+        detector = VideoHighlightDetector(model_path=model_name)
+        results = detector.process_video(
+            video_path=temp_video_path,
+            output_path=output_path,
+            segment_length=segment_length,
+            with_effects=with_effects
         )
-        
+
+        if "error" in results:
+            raise HTTPException(status_code=500, detail=results["error"])
+
+        with open(analysis_path, 'w') as f:
+            json.dump(results, f, indent=2)
+
         return AnalysisResponse(
-            job_id=job_id,
-            status="queued",
-            message="Video uploaded successfully. Processing started."
+            success=True,
+            message="Video description generated successfully",
+            video_description=results.get("video_description", ""),
+            analysis_file=analysis_path
         )
-        
     except Exception as e:
-        # Clean up on error
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=f"Failed to process upload: {str(e)}")
+    finally:
         if os.path.exists(temp_video_path):
             os.unlink(temp_video_path)
-        raise HTTPException(status_code=500, detail=f"Failed to process upload: {str(e)}")
-
-@app.get("/job-status/{job_id}", response_model=JobStatus)
-async def get_job_status(job_id: str):
-    """Get processing status for a job"""
-    
-    # Check completed jobs first
-    if job_id in completed_jobs:
-        return JobStatus(**completed_jobs[job_id])
-    
-    # Check active jobs
-    if job_id in active_jobs:
-        return JobStatus(**active_jobs[job_id])
-    
-    # Job not found
-    raise HTTPException(status_code=404, detail="Job not found")
-
-@app.get("/download/{filename}")
-async def download_file(filename: str):
-    """Download generated highlights or analysis file"""
-    file_path = os.path.join(OUTPUTS_DIR, filename)
-    
-    if not os.path.exists(file_path):
-        raise HTTPException(status_code=404, detail="File not found")
-    
-    # Determine media type
-    if filename.endswith('.mp4'):
-        media_type = 'video/mp4'
-    elif filename.endswith('.json'):
-        media_type = 'application/json'
-    else:
-        media_type = 'application/octet-stream'
-    
-    return FileResponse(
-        path=file_path,
-        media_type=media_type,
-        filename=filename
-    )
-
-@app.get("/jobs")
-async def list_jobs():
-    """List all jobs (for debugging)"""
-    return {
-        "active_jobs": len(active_jobs),
-        "completed_jobs": len(completed_jobs),
-        "active": list(active_jobs.keys()),
-        "completed": list(completed_jobs.keys())
-    }
-
-@app.delete("/cleanup")
-async def cleanup_old_jobs():
-    """Clean up old completed jobs and files"""
-    cleaned_jobs = 0
-    cleaned_files = 0
-    
-    # Keep only last 10 completed jobs
-    if len(completed_jobs) > 10:
-        jobs_to_remove = list(completed_jobs.keys())[:-10]
-        for job_id in jobs_to_remove:
-            del completed_jobs[job_id]
-            cleaned_jobs += 1
-    
-    # Clean up old files (keep only files from last 20 jobs)
-    all_jobs = list(active_jobs.keys()) + list(completed_jobs.keys())
-    
-    try:
-        for filename in os.listdir(OUTPUTS_DIR):
-            file_job_id = filename.split('_')[0]
-            if file_job_id not in all_jobs:
-                file_path = os.path.join(OUTPUTS_DIR, filename)
-                os.unlink(file_path)
-                cleaned_files += 1
-    except Exception as e:
-        logger.error(f"Error during cleanup: {e}")
-    
-    return {
-        "message": "Cleanup completed",
-        "cleaned_jobs": cleaned_jobs,
-        "cleaned_files": cleaned_files
-    }
 
 if __name__ == "__main__":
     import uvicorn

test_api.py

@@ -1,11 +1,7 @@
 #!/usr/bin/env python3
-"""
-Test script for the HuggingFace Segment-Based Video Highlights API
-"""
+"""Test script for the current synchronous upload-video API."""
 
 import requests
-import time
-import json
 from pathlib import Path
 
 # API configuration
@@ -13,7 +9,7 @@ API_BASE = "http://localhost:7860"  # Change to your deployed URL
 TEST_VIDEO = "../test_video/test.mp4"  # Adjust path as needed
 
 def test_api():
-    """Test the complete API workflow"""
+    """Test health + upload-video workflow."""
     print("🧪 Testing HuggingFace Segment-Based Video Highlights API")
     
     # Check if test video exists
@@ -42,39 +38,12 @@ def test_api():
             print(f"❌ Upload failed: {response.status_code} - {response.text}")
             return
         
-        job_data = response.json()
-        job_id = job_data['job_id']
-        print(f"✅ Video uploaded successfully! Job ID: {job_id}")
-        
-        # 3. Monitor job status
-        print("\n3️⃣ Monitoring job progress...")
-        while True:
-            response = requests.get(f"{API_BASE}/job-status/{job_id}")
-            if response.status_code != 200:
-                print(f"❌ Status check failed: {response.status_code}")
-                break
-            
-            status_data = response.json()
-            print(f"Status: {status_data['status']} - {status_data['message']} ({status_data['progress']}%)")
-            
-            if status_data['status'] == 'completed':
-                print(f"✅ Processing completed!")
-                print(f"📹 Highlights URL: {status_data['highlights_url']}")
-                print(f"📊 Analysis URL: {status_data['analysis_url']}")
-                print(f"🎬 Segments: {status_data['selected_segments']}/{status_data['total_segments']}")
-                print(f"📈 Compression: {status_data['compression_ratio']:.1%}")
-                break
-            elif status_data['status'] == 'failed':
-                print(f"❌ Processing failed: {status_data['message']}")
-                break
-            
-            time.sleep(5)  # Wait 5 seconds before checking again
-        
-        # 4. Download results (optional)
-        if status_data['status'] == 'completed':
-            print("\n4️⃣ Download URLs available:")
-            print(f"Highlights: {API_BASE}{status_data['highlights_url']}")
-            print(f"Analysis: {API_BASE}{status_data['analysis_url']}")
+        result = response.json()
+        print("✅ Upload and processing completed!")
+        print(f"Success: {result.get('success')}")
+        print(f"Message: {result.get('message')}")
+        print(f"Video Description: {result.get('video_description')}")
+        print(f"Analysis File: {result.get('analysis_file')}")
     
     except requests.exceptions.ConnectionError:
         print(f"❌ Cannot connect to API at {API_BASE}")