Download api.py from Stroke-ia/API: direct link, hf CLI and curl.
- Browser
- Download file 7.39 kB
-
https://huggingface.co/spaces/Stroke-ia/API/resolve/main/api.py
- Command line
-
hf download hf://spaces/Stroke-ia/API/api.py
-
curl -L -o api.py https://huggingface.co/spaces/Stroke-ia/API/resolve/main/api.py
7.39 kB
| from fastapi import FastAPI, UploadFile, File, HTTPException, Security, Depends | |
| from fastapi.security.api_key import APIKeyHeader | |
| from fastapi.responses import JSONResponse, StreamingResponse | |
| import uvicorn | |
| import logging | |
| import io | |
| import time | |
| import numpy as np | |
| from PIL import Image | |
| import cv2 | |
| from ultralytics import YOLO | |
| import mediapipe as mp | |
| # ========================== | |
| # 🔑 Sécurité : API Key | |
| # ========================== | |
| API_KEY = "1234" # ⚠️ change avant de partager | |
| api_key_header = APIKeyHeader(name="X-API-Key") | |
| def verify_api_key(api_key: str = Security(api_key_header)): | |
| if api_key != API_KEY: | |
| raise HTTPException(status_code=403, detail="Forbidden") | |
| return api_key | |
| # ========================== | |
| # 📝 Logger | |
| # ========================== | |
| logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s") | |
| logger = logging.getLogger("stroke-api") | |
| # ========================== | |
| # 🚀 App | |
| # ========================== | |
| app = FastAPI( | |
| title="Stroke Detection API", | |
| version="1.2.0", | |
| description="🚑 Stroke Detection API using YOLOv8 + Face Detection (MediaPipe). Research/demo only." | |
| ) | |
| # ========================== | |
| # 📦 Chargement modèles | |
| # ========================== | |
| try: | |
| model = YOLO("best.pt") | |
| logger.info("✅ YOLO model loaded.") | |
| except Exception as e: | |
| logger.exception("❌ Failed to load YOLO model") | |
| raise RuntimeError(f"Model loading failed: {e}") | |
| mp_face_detection = mp.solutions.face_detection | |
| # ========================== | |
| # 🔧 Utilitaires | |
| # ========================== | |
| ALLOWED_EXT = (".png", ".jpg", ".jpeg") | |
| ALLOWED_MIME = {"image/png", "image/jpeg"} | |
| MAX_BYTES = 8 * 1024 * 1024 # 8 MB | |
| CROP_ON_FACE = True | |
| def _validate_file(file: UploadFile, raw: bytes): | |
| if not file.filename.lower().endswith(ALLOWED_EXT): | |
| raise HTTPException(status_code=400, detail="Invalid file extension") | |
| if (file.content_type or "").lower() not in ALLOWED_MIME and file.content_type: | |
| raise HTTPException(status_code=400, detail="Invalid content-type") | |
| if len(raw) > MAX_BYTES: | |
| raise HTTPException(status_code=413, detail=f"Image too large. Max {MAX_BYTES//(1024*1024)} MB") | |
| def _read_image_to_numpy(raw: bytes) -> np.ndarray: | |
| try: | |
| img = Image.open(io.BytesIO(raw)).convert("RGB") | |
| return np.array(img) | |
| except Exception: | |
| raise HTTPException(status_code=400, detail="Unreadable image file") | |
| def _largest_face_bbox(np_img: np.ndarray, min_conf: float = 0.6): | |
| h, w = np_img.shape[:2] | |
| with mp_face_detection.FaceDetection(min_detection_confidence=min_conf) as fd: | |
| results = fd.process(cv2.cvtColor(np_img, cv2.COLOR_RGB2BGR)) | |
| if not results.detections: | |
| return None | |
| boxes = [] | |
| for det in results.detections: | |
| rel = det.location_data.relative_bounding_box | |
| x1 = int(max(0, rel.xmin) * w) | |
| y1 = int(max(0, rel.ymin) * h) | |
| x2 = int(min(1.0, rel.xmin + rel.width) * w) | |
| y2 = int(min(1.0, rel.ymin + rel.height) * h) | |
| boxes.append((x1, y1, x2, y2)) | |
| boxes.sort(key=lambda b: (b[2]-b[0])*(b[3]-b[1]), reverse=True) | |
| return boxes[0] if boxes else None | |
| def _crop_to_bbox(np_img: np.ndarray, bbox, margin: float = 0.15) -> np.ndarray: | |
| h, w = np_img.shape[:2] | |
| x1, y1, x2, y2 = bbox | |
| bw, bh = x2 - x1, y2 - y1 | |
| dx, dy = int(bw*margin), int(bh*margin) | |
| X1, Y1 = max(0,x1-dx), max(0,y1-dy) | |
| X2, Y2 = min(w,x2+dx), min(h,y2+dy) | |
| return np_img[Y1:Y2, X1:X2].copy() | |
| def _annotate_face_box(np_img: np.ndarray, bbox) -> np.ndarray: | |
| annotated = cv2.cvtColor(np_img, cv2.COLOR_RGB2BGR).copy() | |
| x1, y1, x2, y2 = bbox | |
| cv2.rectangle(annotated, (x1, y1), (x2, y2), (0,255,0), 2) | |
| return annotated | |
| # ========================== | |
| # 🩺 Healthcheck | |
| # ========================== | |
| async def health(): | |
| return {"status": "ok", "model_loaded": True} | |
| # ========================== | |
| # 📦 Endpoint JSON | |
| # ========================== | |
| async def predict(file: UploadFile = File(...), api_key: str = Depends(verify_api_key)): | |
| raw = await file.read() | |
| _validate_file(file, raw) | |
| try: | |
| np_img = _read_image_to_numpy(raw) | |
| face_bbox = _largest_face_bbox(np_img) | |
| if face_bbox is None: | |
| return JSONResponse(status_code=422, content={"status":"error","message":"Aucun visage détecté"}) | |
| input_img = _crop_to_bbox(np_img, face_bbox) if CROP_ON_FACE else np_img | |
| start_time = time.time() | |
| results = model.predict(source=input_img, verbose=False) | |
| elapsed = time.time() - start_time | |
| output = [{"class": r.names[int(box.cls[0].item())], | |
| "confidence": float(box.conf[0].item()), | |
| "bbox": box.xyxy[0].tolist()} | |
| for r in results for box in r.boxes] | |
| return JSONResponse(content={ | |
| "status": "ok", | |
| "face_detected": True, | |
| "face_bbox": list(map(int, face_bbox)), | |
| "predictions": output, | |
| "inference_time_sec": round(elapsed,3) | |
| }) | |
| except Exception as e: | |
| logger.exception("Error in /v1/predict") | |
| raise HTTPException(status_code=500, detail=str(e)) | |
| # ========================== | |
| # 🖼️ Endpoint Image annotée | |
| # ========================== | |
| async def predict_image(file: UploadFile = File(...), api_key: str = Depends(verify_api_key)): | |
| raw = await file.read() | |
| _validate_file(file, raw) | |
| try: | |
| np_img = _read_image_to_numpy(raw) | |
| face_bbox = _largest_face_bbox(np_img) | |
| if face_bbox is None: | |
| return JSONResponse(status_code=422, content={"status":"error","message":"Aucun visage détecté"}) | |
| input_img = _crop_to_bbox(np_img, face_bbox) if CROP_ON_FACE else np_img | |
| start_time = time.time() | |
| results = model.predict(source=input_img, verbose=False) | |
| elapsed = time.time() - start_time | |
| yolo_annot = cv2.cvtColor(results[0].plot(), cv2.COLOR_BGR2RGB) | |
| out_rgb = yolo_annot if CROP_ON_FACE else _annotate_face_box(np_img, face_bbox) | |
| pil_img = Image.fromarray(out_rgb) | |
| buf = io.BytesIO() | |
| pil_img.save(buf, format="PNG") | |
| buf.seek(0) | |
| headers = {"X-Inference-Time": str(round(elapsed,3))} | |
| return StreamingResponse(buf, media_type="image/png", headers=headers) | |
| except Exception as e: | |
| logger.exception("Error in /v1/predict_image") | |
| raise HTTPException(status_code=500, detail=str(e)) | |
| # ========================== | |
| # 🧪 Test automatique | |
| # ========================== | |
| async def test_upload(): | |
| try: | |
| file_path = "test.jpg" | |
| np_img = _read_image_to_numpy(open(file_path,"rb").read()) | |
| face_bbox = _largest_face_bbox(np_img) | |
| if not face_bbox: | |
| return {"status":"error","message":"Aucun visage détecté"} | |
| results = model.predict(source=np_img, verbose=False) | |
| return {"status":"ok","face_detected":True,"num_detections":len(results[0].boxes)} | |
| except Exception as e: | |
| return {"status":"error","message": str(e)} | |
| # ========================== | |
| # 🚀 Lancement local | |
| # ========================== | |
| if __name__ == "__main__": | |
| uvicorn.run(app, host="0.0.0.0", port=7860) | |