Upload InternVL2 implementation

app_internvl2.py

@@ -197,31 +197,44 @@ def analyze_image(image, prompt):
             # If somehow it's already a PIL Image
             image_pil = image.convert('RGB')
         
-        # Run inference with the model, handling event loop manually
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # If we're in a running event loop (like Gradio's),
-            # we need to use run_in_executor for blocking operations
-            print("Using threaded execution for model inference")
-            # Define a function that will run in a separate thread
-            def run_inference():
-                return internvl2_pipeline((prompt, image_pil))
-                
-            # Run the inference in a thread pool executor
-            response = loop.run_in_executor(None, run_inference)
-            # Wait for the result
-            if hasattr(response, "result"):
-                response = response.result()
-        else:
-            # Standard synchronous execution
-            print("Using standard execution for model inference")
-            response = internvl2_pipeline((prompt, image_pil))
+        # Completely bypass asyncio by using a dedicated thread for model inference
+        import threading
+        import queue
+        
+        result_queue = queue.Queue()
+        
+        def run_inference_in_thread():
+            try:
+                # Run the model in a dedicated thread
+                response = internvl2_pipeline((prompt, image_pil))
+                result_text = response.text if hasattr(response, "text") else str(response)
+                result_queue.put(("success", result_text))
+            except Exception as e:
+                result_queue.put(("error", str(e)))
         
-        # Get the response text
-        result = response.text if hasattr(response, "text") else str(response)
+        # Start a dedicated thread for inference
+        print("Running model inference in a dedicated thread")
+        inference_thread = threading.Thread(target=run_inference_in_thread)
+        inference_thread.daemon = True  # Allow the thread to be terminated when the main program exits
+        inference_thread.start()
         
-        elapsed_time = time.time() - start_time
-        return result
+        # Wait for the thread to complete (with timeout)
+        inference_thread.join(timeout=120)  # 2 minute timeout
+        
+        if inference_thread.is_alive():
+            # If the thread is still running after timeout
+            return "Model inference timed out after 120 seconds. The model might be too slow on this hardware."
+        
+        # Get the result from the queue
+        if not result_queue.empty():
+            status, result = result_queue.get()
+            if status == "error":
+                return f"Error in model inference: {result}"
+            else:
+                elapsed_time = time.time() - start_time
+                return result
+        else:
+            return "Unknown error: Model inference did not produce a result"
         
     except Exception as e:
         print(f"Error in image analysis: {str(e)}")