fix for async methods as per PR

app/api/controllers.py

@@ -1,5 +1,6 @@
 """API controllers for request handling and validation."""
 
+import asyncio
 from fastapi import HTTPException
 
 from app.core.logging import logger
@@ -23,7 +24,7 @@ class PredictionController:
             if not request.image.mediaType.startswith('image/'):
                 raise HTTPException(400, f"Invalid media type: {request.image.mediaType}")
 
-            return await service.predict(request)
+            return await asyncio.to_thread(service.predict, request)
 
         except HTTPException:
             raise

app/core/app.py

@@ -1,5 +1,6 @@
 """FastAPI application factory and core infrastructure."""
 
+import asyncio
 import warnings
 from contextlib import asynccontextmanager
 from typing import AsyncGenerator, Optional
@@ -41,7 +42,7 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
 
             # Replace ResNetInferenceService with your own implementation
             service = ResNetInferenceService(model_name="microsoft/resnet-18")
-            await service.load_model()
+            await asyncio.to_thread(service.load_model)
             set_inference_service(service)
 
         logger.info("Startup completed successfully")

app/services/base.py

@@ -11,18 +11,15 @@ TResponse = TypeVar('TResponse', bound=BaseModel)
 class InferenceService(ABC, Generic[TRequest, TResponse]):
     """
     Base class for inference services. Subclass this to integrate your model.
-
-    For CPU-intensive inference, offload work to a background thread using
-    asyncio.to_thread() to avoid blocking the event loop.
     """
 
     @abstractmethod
-    async def load_model(self) -> None:
+    def load_model(self) -> None:
         """Load model weights and processors. Called once at startup."""
         pass
 
     @abstractmethod
-    async def predict(self, request: TRequest) -> TResponse:
+    def predict(self, request: TRequest) -> TResponse:
         """Run inference and return typed response."""
         pass
 

app/services/inference.py

@@ -2,7 +2,6 @@
 
 import os
 import base64
-import asyncio
 from io import BytesIO
 import torch
 from PIL import Image
@@ -24,7 +23,7 @@ class ResNetInferenceService(InferenceService[ImageRequest, PredictionResponse])
         self.model_path = os.path.join("models", model_name)
         logger.info(f"Initializing ResNet service: {self.model_path}")
 
-    async def load_model(self) -> None:
+    def load_model(self) -> None:
         if self._is_loaded:
             return
 
@@ -50,8 +49,7 @@ class ResNetInferenceService(InferenceService[ImageRequest, PredictionResponse])
         self._is_loaded = True
         logger.info(f"Model loaded: {len(self.model.config.id2label)} classes")
 
-    def _predict_sync(self, request: ImageRequest) -> PredictionResponse:
-        """Synchronous inference logic. Runs in background thread."""
+    def predict(self, request: ImageRequest) -> PredictionResponse:
         image_data = base64.b64decode(request.image.data)
         image = Image.open(BytesIO(image_data))
 
@@ -76,13 +74,6 @@ class ResNetInferenceService(InferenceService[ImageRequest, PredictionResponse])
             mediaType=request.image.mediaType
         )
 
-    async def predict(self, request: ImageRequest) -> PredictionResponse:
-        """Run inference with background threading to avoid blocking event loop."""
-        if not self._is_loaded:
-            await self.load_model()
-
-        return await asyncio.to_thread(self._predict_sync, request)
-
     @property
     def is_loaded(self) -> bool:
         return self._is_loaded