updated the app

app.py

@@ -73,106 +73,131 @@ def run_example(image, model_id="Qwen/Qwen2.5-VL-7B-Instruct", run_ner=False, ne
     # First get the OCR text
     text_input = "Convert the image to text."
     
-    # Handle various image input formats
-    if image is None:
-        raise ValueError("Image path is None.")
+    # Print debug info about the image type
+    print(f"Image type: {type(image)}")
+    print(f"Image value: {image}")
     
-    # Case 1: Image is a dictionary with base64 data (from API calls)
-    if isinstance(image, dict) and 'data' in image and isinstance(image['data'], str):
-        if image['data'].startswith('data:image'):
-            # Extract the base64 part after the comma
-            base64_data = image['data'].split(',', 1)[1]
-            # Convert base64 to bytes and then to PIL Image
-            image_bytes = base64.b64decode(base64_data)
-            pil_image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-            # Convert to numpy array for further processing
+    # Robust handling of image input
+    try:
+        # Handle None or empty input
+        if image is None:
+            raise ValueError("Image input is None")
+            
+        # Handle dictionary input (from API)
+        if isinstance(image, dict):
+            if 'data' in image and isinstance(image['data'], str) and image['data'].startswith('data:image'):
+                # Extract the base64 part
+                base64_data = image['data'].split(',', 1)[1]
+                # Convert base64 to bytes, then to PIL Image
+                image_bytes = base64.b64decode(base64_data)
+                pil_image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+                # Convert to numpy array
+                image = np.array(pil_image)
+            else:
+                raise ValueError(f"Invalid image dictionary format: {image}")
+        
+        # Convert string path to image if needed
+        if isinstance(image, str):
+            pil_image = Image.open(image).convert("RGB")
             image = np.array(pil_image)
-    
-    # Convert numpy array to image path
-    image_path = array_to_image_path(image)
-    
-    model = models[model_id]
-    processor = processors[model_id]
-    
-    prompt = f"{user_prompt}<|image_1|>\n{text_input}{prompt_suffix}{assistant_prompt}"
-    image = Image.fromarray(image).convert("RGB")
-    messages = [
-    {
-            "role": "user",
-            "content": [
-                {
-                    "type": "image",
-                    "image": image_path,
-                },
-                {"type": "text", "text": text_input},
-            ],
-        }
-    ]
-    
-    # Preparation for inference
-    text = processor.apply_chat_template(
-        messages, tokenize=False, add_generation_prompt=True
-    )
-    image_inputs, video_inputs = process_vision_info(messages)
-    inputs = processor(
-        text=[text],
-        images=image_inputs,
-        videos=video_inputs,
-        padding=True,
-        return_tensors="pt",
-    )
-    inputs = inputs.to("cuda")
-    
-    # Inference: Generation of the output
-    generated_ids = model.generate(**inputs, max_new_tokens=1024)
-    generated_ids_trimmed = [
-        out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
-    ]
-    output_text = processor.batch_decode(
-        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
-    )
-    
-    ocr_text = output_text[0]
-    
-    # If NER is enabled, process the OCR text
-    if run_ner:
-        ner_results = gliner_model.predict_entities(
-            ocr_text,
-            ner_labels.split(","),
-            threshold=0.3
+            
+        # Ensure image is a numpy array
+        if not isinstance(image, np.ndarray):
+            raise ValueError(f"Unsupported image type: {type(image)}")
+            
+        # Convert numpy array to image path
+        image_path = array_to_image_path(image)
+        
+        model = models[model_id]
+        processor = processors[model_id]
+        
+        prompt = f"{user_prompt}<|image_1|>\n{text_input}{prompt_suffix}{assistant_prompt}"
+        pil_image = Image.fromarray(image).convert("RGB")
+        messages = [
+        {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image",
+                        "image": image_path,
+                    },
+                    {"type": "text", "text": text_input},
+                ],
+            }
+        ]
+        
+        # Preparation for inference
+        text = processor.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=True
+        )
+        image_inputs, video_inputs = process_vision_info(messages)
+        inputs = processor(
+            text=[text],
+            images=image_inputs,
+            videos=video_inputs,
+            padding=True,
+            return_tensors="pt",
         )
+        inputs = inputs.to("cuda")
         
-        # Create a list of tuples (text, label) for highlighting
-        highlighted_text = []
-        last_end = 0
+        # Inference: Generation of the output
+        generated_ids = model.generate(**inputs, max_new_tokens=1024)
+        generated_ids_trimmed = [
+            out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+        ]
+        output_text = processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+        )
         
-        # Sort entities by start position
-        sorted_entities = sorted(ner_results, key=lambda x: x["start"])
+        ocr_text = output_text[0]
         
-        # Process each entity and add non-entity text segments
-        for entity in sorted_entities:
-            # Add non-entity text before the current entity
-            if last_end < entity["start"]:
-                highlighted_text.append((ocr_text[last_end:entity["start"]], None))
+        # If NER is enabled, process the OCR text
+        if run_ner:
+            ner_results = gliner_model.predict_entities(
+                ocr_text,
+                ner_labels.split(","),
+                threshold=0.3
+            )
             
-            # Add the entity text with its label
-            highlighted_text.append((
-                ocr_text[entity["start"]:entity["end"]],
-                entity["label"]
-            ))
-            last_end = entity["end"]
-        
-        # Add any remaining text after the last entity
-        if last_end < len(ocr_text):
-            highlighted_text.append((ocr_text[last_end:], None))
+            # Create a list of tuples (text, label) for highlighting
+            highlighted_text = []
+            last_end = 0
+            
+            # Sort entities by start position
+            sorted_entities = sorted(ner_results, key=lambda x: x["start"])
+            
+            # Process each entity and add non-entity text segments
+            for entity in sorted_entities:
+                # Add non-entity text before the current entity
+                if last_end < entity["start"]:
+                    highlighted_text.append((ocr_text[last_end:entity["start"]], None))
+                
+                # Add the entity text with its label
+                highlighted_text.append((
+                    ocr_text[entity["start"]:entity["end"]],
+                    entity["label"]
+                ))
+                last_end = entity["end"]
+            
+            # Add any remaining text after the last entity
+            if last_end < len(ocr_text):
+                highlighted_text.append((ocr_text[last_end:], None))
+            
+            # Create TextWithMetadata instance with the highlighted text and metadata
+            result = TextWithMetadata(highlighted_text, original_text=ocr_text, entities=ner_results)
+            return result, result  # Return twice: once for display, once for state
         
-        # Create TextWithMetadata instance with the highlighted text and metadata
-        result = TextWithMetadata(highlighted_text, original_text=ocr_text, entities=ner_results)
+        # If NER is disabled, return the text without highlighting
+        result = TextWithMetadata([(ocr_text, None)], original_text=ocr_text, entities=[])
         return result, result  # Return twice: once for display, once for state
-    
-    # If NER is disabled, return the text without highlighting
-    result = TextWithMetadata([(ocr_text, None)], original_text=ocr_text, entities=[])
-    return result, result  # Return twice: once for display, once for state
+        
+    except Exception as e:
+        import traceback
+        print(f"Error processing image: {e}")
+        print(traceback.format_exc())
+        # Return empty result on error
+        result = TextWithMetadata([("Error processing image: " + str(e), None)], original_text="Error: " + str(e), entities=[])
+        return result, result
 
 
 with gr.Blocks() as demo:

call.py

@@ -15,7 +15,7 @@ dotenv.load_dotenv()
 hf_token = os.getenv("HF_TOKEN")
 
 # Create client for the Hugging Face Space with authentication
-client = Client("wjbmattingly/caracal-api", hf_token=hf_token)
+client = Client("wjbmattingly/carcal-api", hf_token=hf_token)
 
 # Example usage
 if __name__ == "__main__":