⚡ Bolt: Optimize Image Pipeline and Upvote Operation

backend/hf_api_service.py

@@ -44,10 +44,16 @@ async def _make_request(client, url, payload):
         logger.error(f"HF API Request Exception: {e}")
         return []
 
-def _prepare_image_bytes(image: Union[Image.Image, bytes]) -> bytes:
+def _prepare_image_bytes(image: Union[Image.Image, bytes, io.BytesIO]) -> bytes:
+    """Helper to ensure image is in bytes format for HF API."""
     if isinstance(image, bytes):
         return image
+    if isinstance(image, io.BytesIO):
+        return image.getvalue()
+
+    # It's a PIL Image
     img_byte_arr = io.BytesIO()
+    # Use JPEG as default if format is missing (e.g. for newly created images)
     fmt = image.format if image.format else 'JPEG'
     image.save(img_byte_arr, format=fmt)
     return img_byte_arr.getvalue()

backend/routers/detection.py

@@ -406,11 +406,8 @@ async def detect_graffiti_endpoint(image: UploadFile = File(...)):
 
 @router.post("/api/detect-traffic-sign")
 async def detect_traffic_sign_endpoint(request: Request, image: UploadFile = File(...)):
-    try:
-        image_bytes = await image.read()
-    except Exception as e:
-        logger.error(f"Invalid image file: {e}", exc_info=True)
-        raise HTTPException(status_code=400, detail="Invalid image file")
+    # Optimized Image Processing: Validation + Optimization
+    _, image_bytes = await process_uploaded_image(image)
 
     try:
         client = get_http_client(request)
@@ -423,11 +420,8 @@ async def detect_traffic_sign_endpoint(request: Request, image: UploadFile = Fil
 
 @router.post("/api/detect-abandoned-vehicle")
 async def detect_abandoned_vehicle_endpoint(request: Request, image: UploadFile = File(...)):
-    try:
-        image_bytes = await image.read()
-    except Exception as e:
-        logger.error(f"Invalid image file: {e}", exc_info=True)
-        raise HTTPException(status_code=400, detail="Invalid image file")
+    # Optimized Image Processing: Validation + Optimization
+    _, image_bytes = await process_uploaded_image(image)
 
     try:
         client = get_http_client(request)

backend/routers/issues.py

@@ -16,7 +16,7 @@
     IssueCreateWithDeduplicationResponse, IssueCategory, NearbyIssueResponse,
     DeduplicationCheckResponse, IssueSummaryResponse, VoteResponse,
     IssueStatusUpdateRequest, IssueStatusUpdateResponse, PushSubscriptionRequest,
-    PushSubscriptionResponse
+    PushSubscriptionResponse, BlockchainVerifyResponse
 )
 from backend.utils import (
     check_upload_limits, validate_uploaded_file, save_file_blocking, save_issue_db,
@@ -70,10 +70,10 @@ async def create_issue(
             image_path = os.path.join(upload_dir, filename)
 
             # Process image (validate, resize, strip EXIF)
-            processed_image = await process_uploaded_image(image)
+            _, processed_bytes = await process_uploaded_image(image)
 
             # Save processed image to disk
-            await run_in_threadpool(save_processed_image, processed_image, image_path)
+            await run_in_threadpool(save_processed_image, processed_bytes, image_path)
     except HTTPException:
         # Re-raise HTTP exceptions (from validation)
         raise
@@ -247,23 +247,29 @@ async def create_issue(
 
 @router.post("/api/issues/{issue_id}/vote", response_model=VoteResponse)
 def upvote_issue(issue_id: int, db: Session = Depends(get_db)):
-    issue = db.query(Issue).filter(Issue.id == issue_id).first()
-    if not issue:
-        raise HTTPException(status_code=404, detail="Issue not found")
+    """
+    Optimized: Atomic upvote without loading full model instance.
+    Directly updates the database and returns only required fields.
+    """
+    # Check existence and increment atomically in one query if possible
+    # but update() in SQLAlchemy doesn't easily return the new value in all dialects (SQLite)
+    # So we do: 1. Update, 2. Fetch only needed columns
 
-    # Increment upvotes atomically
-    if issue.upvotes is None:
-        issue.upvotes = 0
+    update_count = db.query(Issue).filter(Issue.id == issue_id).update({
+        Issue.upvotes: func.coalesce(Issue.upvotes, 0) + 1
+    }, synchronize_session=False)
 
-    # Use SQLAlchemy expression for atomic update
-    issue.upvotes = Issue.upvotes + 1
+    if not update_count:
+        raise HTTPException(status_code=404, detail="Issue not found")
 
     db.commit()
-    db.refresh(issue)
+
+    # Fetch only needed data for response
+    row = db.query(Issue.id, Issue.upvotes).filter(Issue.id == issue_id).first()
 
     return VoteResponse(
-        id=issue.id,
-        upvotes=issue.upvotes,
+        id=row.id,
+        upvotes=row.upvotes or 0,
         message="Issue upvoted successfully"
     )
 
@@ -340,16 +346,8 @@ async def verify_issue_endpoint(
         raise HTTPException(status_code=404, detail="Issue not found")
 
     if image:
-        # AI Verification Logic
-        # Validate uploaded file
-        await validate_uploaded_file(image)
-        # We can ignore the returned PIL image here as we need bytes for the external API
-
-        try:
-            image_bytes = await image.read()
-        except Exception as e:
-            logger.error(f"Invalid image file: {e}", exc_info=True)
-            raise HTTPException(status_code=400, detail="Invalid image file")
+        # AI Verification Logic (Optimized Pipeline)
+        _, image_bytes = await process_uploaded_image(image)
 
         # Construct question
         category = issue.category.lower() if issue.category else "issue"
@@ -613,3 +611,34 @@ def get_recent_issues(
     # Thread-safe cache update
     recent_issues_cache.set(data, cache_key)
     return data
+
+@router.get("/api/issues/{issue_id}/blockchain-verify", response_model=BlockchainVerifyResponse)
+async def verify_issue_blockchain(issue_id: int, db: Session = Depends(get_db)):
+    """
+    Blockchain Verification: Verifies the integrity seal of a report.
+    Checks if the hash of the current issue matches its content and the previous hash.
+    """
+    # Fetch current issue and its predecessor's hash
+    issue = await run_in_threadpool(lambda: db.query(Issue).filter(Issue.id == issue_id).first())
+    if not issue:
+        raise HTTPException(status_code=404, detail="Issue not found")
+
+    # Get predecessor hash
+    prev_issue = await run_in_threadpool(
+        lambda: db.query(Issue.integrity_hash).filter(Issue.id < issue_id).order_by(Issue.id.desc()).first()
+    )
+    prev_hash = prev_issue[0] if prev_issue and prev_issue[0] else ""
+
+    # Recalculate hash
+    hash_content = f"{issue.description}|{issue.category}|{prev_hash}"
+    calculated_hash = hashlib.sha256(hash_content.encode()).hexdigest()
+
+    is_valid = (calculated_hash == issue.integrity_hash)
+
+    return BlockchainVerifyResponse(
+        issue_id=issue.id,
+        is_valid=is_valid,
+        integrity_hash=issue.integrity_hash or "",
+        calculated_hash=calculated_hash,
+        previous_hash=prev_hash
+    )

backend/schemas.py

@@ -266,3 +266,10 @@ class ClosureStatusResponse(BaseModel):
     required_confirmations: int = Field(..., description="Number of confirmations needed")
     confirmation_deadline: Optional[datetime] = Field(None, description="Deadline for confirmations")
     days_remaining: Optional[int] = Field(None, description="Days until deadline")
+
+class BlockchainVerifyResponse(BaseModel):
+    issue_id: int = Field(..., description="Issue ID")
+    is_valid: bool = Field(..., description="Whether the integrity seal is valid")
+    integrity_hash: str = Field(..., description="Current integrity hash")
+    calculated_hash: str = Field(..., description="Calculated hash for verification")
+    previous_hash: str = Field(..., description="Previous hash in the chain")

backend/utils.py

@@ -138,10 +138,10 @@ async def validate_uploaded_file(file: UploadFile) -> Optional[Image.Image]:
     """
     return await run_in_threadpool(_validate_uploaded_file_sync, file)
 
-def process_uploaded_image_sync(file: UploadFile) -> io.BytesIO:
+def process_uploaded_image_sync(file: UploadFile):
     """
     Synchronously validate, resize, and strip EXIF from uploaded image.
-    Returns the processed image data as BytesIO.
+    Returns a tuple of (PIL.Image.Image, bytes).
     """
     # Check file size
     file.file.seek(0, 2)
@@ -180,14 +180,14 @@ def process_uploaded_image_sync(file: UploadFile) -> io.BytesIO:
             img_no_exif = Image.new(img.mode, img.size)
             img_no_exif.paste(img)
 
-            # Save to BytesIO
+            # Save to bytes
             output = io.BytesIO()
             # Preserve format or default to JPEG
             fmt = img.format or 'JPEG'
             img_no_exif.save(output, format=fmt, quality=85)
-            output.seek(0)
+            image_bytes = output.getvalue()
 
-            return output
+            return img_no_exif, image_bytes
 
         except Exception as pil_error:
             logger.error(f"PIL processing failed: {pil_error}")
@@ -202,28 +202,28 @@ def process_uploaded_image_sync(file: UploadFile) -> io.BytesIO:
         logger.error(f"Error processing file: {e}")
         raise HTTPException(status_code=400, detail="Unable to process file.")
 
-async def process_uploaded_image(file: UploadFile) -> io.BytesIO:
+async def process_uploaded_image(file: UploadFile):
+    """
+    Asynchronously validate, resize, and strip EXIF from uploaded image.
+    Returns a tuple of (PIL.Image.Image, bytes).
+    """
     return await run_in_threadpool(process_uploaded_image_sync, file)
 
-def save_processed_image(file_obj: io.BytesIO, path: str):
-    """Save processed BytesIO to disk."""
+def save_processed_image(image_bytes: bytes, path: str):
+    """Save processed bytes to disk."""
     with open(path, "wb") as buffer:
-        shutil.copyfileobj(file_obj, buffer)
+        buffer.write(image_bytes)
 
 async def process_and_detect(image: UploadFile, detection_func) -> DetectionResponse:
     """
     Helper to process uploaded image and run detection.
-    Uses the optimized image processing pipeline.
+    Uses the optimized single-pass image processing pipeline.
     """
-    # Validate uploaded file
-    pil_image = await validate_uploaded_file(image)
+    # Optimized: Use process_uploaded_image which resizes and strips EXIF in one go
+    pil_image, _ = await process_uploaded_image(image)
 
     # Validate image for processing (check integrity)
     try:
-        if pil_image is None:
-            pil_image = await run_in_threadpool(Image.open, image.file)
-
-        # Validate image for processing
         await run_in_threadpool(validate_image_for_processing, pil_image)
     except HTTPException:
         raise  # Re-raise HTTP exceptions from validation

tests/test_issue_creation.py

@@ -36,7 +36,8 @@ def test_create_issue():
              patch("backend.tasks.generate_action_plan", new_callable=AsyncMock) as mock_plan:
 
             import io
-            mock_process.return_value = io.BytesIO(b"processed image bytes")
+            from PIL import Image
+            mock_process.return_value = (Image.new('RGB', (10, 10)), b"processed image bytes")
 
             mock_plan.return_value = {
                 "whatsapp": "Test WhatsApp",

tests/test_verification_feature.py

@@ -85,11 +85,12 @@ def mock_refresh(instance):
         app.dependency_overrides = {}
 
 # Test AI Verification
-@patch("backend.routers.issues.validate_uploaded_file", new_callable=AsyncMock)
+@patch("backend.routers.issues.process_uploaded_image", new_callable=AsyncMock)
 @patch("backend.routers.issues.verify_resolution_vqa", new_callable=AsyncMock)
-def test_ai_verification_resolved(mock_vqa, mock_validate, client):
+def test_ai_verification_resolved(mock_vqa, mock_process, client):
     # Setup mocks
-    mock_validate.return_value = None
+    from PIL import Image
+    mock_process.return_value = (Image.new('RGB', (10, 10)), b"fakeimage")
     mock_vqa.return_value = {
         "answer": "no",
         "confidence": 0.95