wip

.flake8

@@ -0,0 +1,3 @@
+[flake8]
+ignore = E501
+max-line-length = 79

Makefile

@@ -0,0 +1,12 @@
+.PHONY: lint format test
+
+lint:
+	flake8 .
+
+format:
+	black .
+
+test:
+	python tests/test_utils.py
+
+all: lint format test

age_estimation/age_estimation.py

@@ -1,12 +1,7 @@
-import os
-import tempfile
 import torch
-import dlib
-
-from PIL import Image
 
 from .model import load_model
-from utils.image_utils import load_image, preprocess_image, get_image_from_input
+from utils.image_utils import preprocess_image, get_image_from_input
 from utils.face_detector import load_face_detector
 from .predict import predict_age
 

age_estimation/predict.py

@@ -1,6 +1,5 @@
 import cv2
 import numpy as np
-import dlib
 import torch
 import torch.nn.functional as F
 

app.py

@@ -1,8 +1,6 @@
 # Standard library imports
 import os
 import gradio as gr
-import torch.nn.functional as F
-import torch.nn as nn
 
 # Local imports
 from age_estimation.age_estimation import age_estimation
@@ -139,8 +137,10 @@ with gr.Blocks() as demo:
         obj_process_btn = gr.Button("Detect Objects")
 
         # Output Components
-        obj_image_output = gr.Image(label="Detected Objects Image") # Updated label for clarity
-        obj_raw_output = gr.JSON(label="Raw Object Detection Data") # Added JSON output
+        obj_image_output = gr.Image(
+            label="Detected Objects Image"
+        )  # Updated label for clarity
+        obj_raw_output = gr.JSON(label="Raw Object Detection Data")  # Added JSON output
 
         # Link radio button change to visibility update function
         obj_input_type.change(
@@ -156,7 +156,7 @@ with gr.Blocks() as demo:
         obj_process_btn.click(
             fn=object_detection,
             inputs=[obj_input_type, obj_img_upload, obj_url_input, obj_base64_input],
-            outputs=[obj_image_output, obj_raw_output], # Updated outputs
+            outputs=[obj_image_output, obj_raw_output],  # Updated outputs
         )
 
     # Launch the Gradio demo

detection/face_detection.py

@@ -3,11 +3,9 @@ import os
 
 # Third-party imports
 import cv2
-import numpy as np
-from PIL import Image
 
 # Local imports
-from utils.image_utils import load_image, preprocess_image, get_image_from_input
+from utils.image_utils import preprocess_image, get_image_from_input
 from utils.face_detector import (
     load_face_detector,
 )  # Assuming this is the dlib detector loader

detection/object_detection.py

@@ -1,10 +1,7 @@
 # Standard library imports
 # (Add any necessary imports for future object detection implementation)
-import json
 
 # Third-party imports
-from PIL import Image
-import numpy as np
 from ultralytics import YOLO
 
 # Local imports
@@ -19,7 +16,7 @@ try:
     print("YOLO model loaded successfully.")
 except Exception as e:
     print(f"Error loading YOLO model: {e}")
-    model = None # Set model to None if loading fails
+    model = None  # Set model to None if loading fails
 
 
 def object_detection(input_type, uploaded_image, image_url, base64_string):
@@ -39,7 +36,7 @@ def object_detection(input_type, uploaded_image, image_url, base64_string):
     """
     if model is None:
         print("YOLO model is not loaded. Cannot perform object detection.")
-        return None, None # Return None for both outputs
+        return None, None  # Return None for both outputs
 
     image = None
     input_value = None
@@ -54,22 +51,22 @@ def object_detection(input_type, uploaded_image, image_url, base64_string):
 
     elif input_type == "Enter Base64" and base64_string and base64_string.strip():
         input_value = base64_string
-        print(f"Using Base64 string for object detection")  # Debug print
+        print("Using Base64 string for object detection")  # Debug print
 
     else:
         print("No valid input provided for object detection based on selected type.")
-        return None, None # Return None for both outputs
+        return None, None  # Return None for both outputs
 
     # If input_value is set (URL or Base64), use load_image
     if input_value:
         image = load_image(input_value)
         if image is None:
-            return None, None # load_image failed
+            return None, None  # load_image failed
 
     # Now 'image' should be a PIL Image or None
     if image is None:
         print("Image is None after loading/selection for object detection.")
-        return None, None # Return None for both outputs
+        return None, None  # Return None for both outputs
 
     try:
         # Preprocess the image (convert PIL to numpy, ensure RGB)
@@ -85,24 +82,37 @@ def object_detection(input_type, uploaded_image, image_url, base64_string):
                 # box.xywh contains [x_center, y_center, width, height]
                 # box.conf contains confidence score
                 # box.cls contains class index
-                x_center, y_center, width, height = [round(float(coord)) for coord in box.xywh[0].tolist()] # Changed to xywh
+                x_center, y_center, width, height = [
+                    round(float(coord)) for coord in box.xywh[0].tolist()
+                ]  # Changed to xywh
                 confidence = round(float(box.conf[0]), 4)
                 class_id = int(box.cls[0])
-                class_name = model.names[class_id] if model.names else str(class_id) # Get class name if available
-
-                raw_data.append({
-                    "box": {"x": x_center, "y": y_center, "w": width, "h": height}, # Updated keys
-                    "confidence": confidence,
-                    "class_id": class_id,
-                    "class_name": class_name
-                })
+                class_name = (
+                    model.names[class_id] if model.names else str(class_id)
+                )  # Get class name if available
+
+                raw_data.append(
+                    {
+                        "box": {
+                            "x": x_center,
+                            "y": y_center,
+                            "w": width,
+                            "h": height,
+                        },  # Updated keys
+                        "confidence": confidence,
+                        "class_id": class_id,
+                        "class_name": class_name,
+                    }
+                )
 
         # Draw results on the image
-        result_image_np = results[0].plot() if results else processed_image_np # Plot if results exist
+        result_image_np = (
+            results[0].plot() if results else processed_image_np
+        )  # Plot if results exist
 
         print("Object detection performed successfully.")
-        return result_image_np, raw_data # Return both the image and raw data
+        return result_image_np, raw_data  # Return both the image and raw data
 
     except Exception as e:
         print(f"Error during YOLO object detection: {e}")
-        return None, None # Return None for both outputs
+        return None, None  # Return None for both outputs

tests/test_utils.py

@@ -0,0 +1,211 @@
+import unittest
+from utils.image_utils import load_image, preprocess_image, get_image_from_input
+from utils.ui_utils import update_input_visibility
+import numpy as np
+from PIL import Image
+import io
+import unittest.mock
+import urllib.request  # Import urllib.request for patching
+import os  # Keep os for file cleanup
+
+
+# Mock object to mimic gr.update return value
+class MockGradioUpdateReturn:
+    def __init__(self, visible=None):
+        self.visible = visible
+
+
+# Simple mock class for urllib.request.urlopen response
+class SimpleMockURLResponse:
+    def __init__(self, content):
+        self._content = content
+
+    def read(self):
+        return self._content
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+
+# Use patch as a class decorator for gr.update
+class TestUtils(unittest.TestCase):
+
+    # Patch urllib.request.urlopen for this specific test
+    @unittest.mock.patch("urllib.request.urlopen")
+    def test_load_image_from_url(
+        self, mock_urlopen
+    ):  # Added mock_urlopen and mock_gr_update
+        # Create a dummy image and get its bytes
+        dummy_image = Image.new("RGB", (10, 10), color="purple")
+        byte_arr = io.BytesIO()
+        dummy_image.save(byte_arr, format="PNG")
+        mock_image_bytes = byte_arr.getvalue()
+
+        # Configure the mock urlopen response using SimpleMockURLResponse
+        mock_urlopen.return_value = SimpleMockURLResponse(mock_image_bytes)
+
+        url = "https://www.example.com/dummy_image.png"  # Use a dummy URL
+        image = load_image(url)
+        self.assertIsNotNone(image)
+        self.assertIsInstance(image, Image.Image)
+        self.assertEqual(image.size, (10, 10))
+        mock_urlopen.assert_called_once_with(url)  # Verify urlopen was called
+
+    def test_load_image_from_base64(self):  # Added mock_gr_update
+        # A simple 1x1 black PNG as a base64 string
+        base64_string = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5ErkJggg=="  # Corrected padding
+        image = load_image(base64_string)
+        self.assertIsNotNone(image)
+        self.assertIsInstance(image, Image.Image)
+        self.assertEqual(image.size, (1, 1))
+
+    def test_load_image_from_file(self):  # Added mock_gr_update
+        # Create a dummy image file for testing
+        dummy_image = Image.new("RGB", (10, 10), color="red")
+        dummy_file_path = "dummy_test_image.png"
+        dummy_image.save(dummy_file_path)
+
+        image = load_image(dummy_file_path)
+        self.assertIsNotNone(image)
+        self.assertIsInstance(image, Image.Image)
+        self.assertEqual(image.size, (10, 10))
+
+        # Clean up the dummy file
+        os.remove(dummy_file_path)
+
+    @unittest.mock.patch("urllib.request.urlopen")
+    def test_load_image_invalid_url(
+        self, mock_urlopen
+    ):  # Added mock_urlopen and mock_gr_update
+        # Configure the mock urlopen to raise an exception
+        mock_urlopen.side_effect = urllib.error.URLError("Simulated network error")
+
+        url = "http://invalid.url/image.jpg"
+        image = load_image(url)
+        self.assertIsNone(image)
+        mock_urlopen.assert_called_once_with(url)
+
+    def test_load_image_invalid_base64(self):  # Added mock_gr_update
+        base64_string = "data:image/png;base64,invalidbase64string"
+        image = load_image(base64_string)
+        self.assertIsNone(image)
+
+    def test_preprocess_image(self):  # Added mock_gr_update
+        # Create a dummy PIL image
+        dummy_image = Image.new("RGB", (20, 20), color="blue")
+        processed_image = preprocess_image(dummy_image)
+        self.assertIsNotNone(processed_image)
+        self.assertIsInstance(processed_image, np.ndarray)
+        self.assertEqual(processed_image.shape, (20, 20, 3))  # Check shape for RGB
+
+    @unittest.mock.patch("urllib.request.urlopen")
+    def test_get_image_from_input_url(
+        self, mock_urlopen
+    ):  # Added mock_urlopen and mock_gr_update
+        # Create a dummy image and get its bytes
+        dummy_image = Image.new("RGB", (30, 30), color="orange")
+        byte_arr = io.BytesIO()
+        dummy_image.save(byte_arr, format="PNG")
+        mock_image_bytes = byte_arr.getvalue()
+
+        # Configure the mock urlopen response using SimpleMockURLResponse
+        mock_urlopen.return_value = SimpleMockURLResponse(mock_image_bytes)
+
+        url = "https://www.example.com/another_dummy_image.png"
+        image = get_image_from_input("Enter URL", None, url, "")
+        self.assertIsNotNone(image)
+        self.assertIsInstance(image, Image.Image)
+        self.assertEqual(image.size, (30, 30))
+        mock_urlopen.assert_called_once_with(url)
+
+    def test_get_image_from_input_upload(self):  # Added mock_gr_update
+        # Mock an uploaded PIL image
+        mock_uploaded_image = Image.new("RGB", (30, 30), color="green")
+        image = get_image_from_input("Upload File", mock_uploaded_image, "", "")
+        self.assertIsNotNone(image)
+        self.assertIsInstance(image, Image.Image)
+        self.assertEqual(image.size, (30, 30))
+
+    def test_get_image_from_input_base64(self):  # Added mock_gr_update
+        base64_string = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="  # Corrected padding
+        image = get_image_from_input("Enter Base64", None, "", base64_string)
+        self.assertIsNotNone(image)
+        self.assertIsInstance(image, Image.Image)
+        self.assertEqual(image.size, (1, 1))
+
+    def test_get_image_from_input_no_input(self):  # Added mock_gr_update
+        image = get_image_from_input("Upload File", None, "", "")
+        self.assertIsNone(image)
+
+    def test_get_image_from_input_invalid_type(self):  # Added mock_gr_update
+        image = get_image_from_input(
+            "Invalid Type", Image.new("RGB", (10, 10)), "url", "base64"
+        )
+        self.assertIsNone(image)
+
+    # Tests for update_input_visibility now use the class-level patch
+    # Configure the side_effect of mock_gr_update to return specific MockGradioUpdateReturn objects
+    @unittest.mock.patch("gradio.update")
+    def test_update_input_visibility_upload(
+        self, mock_gr_update
+    ):  # Added mock_gr_update
+        mock_gr_update.side_effect = [
+            MockGradioUpdateReturn(visible=True),
+            MockGradioUpdateReturn(visible=False),
+            MockGradioUpdateReturn(visible=False),
+        ]
+        updates = update_input_visibility("Upload File")
+        self.assertEqual(len(updates), 3)
+        self.assertTrue(updates[0].visible)
+        self.assertFalse(updates[1].visible)
+        self.assertFalse(updates[2].visible)
+
+    @unittest.mock.patch("gradio.update")
+    def test_update_input_visibility_url(self, mock_gr_update):  # Added mock_gr_update
+        mock_gr_update.side_effect = [
+            MockGradioUpdateReturn(visible=False),
+            MockGradioUpdateReturn(visible=True),
+            MockGradioUpdateReturn(visible=False),
+        ]
+        updates = update_input_visibility("Enter URL")
+        self.assertEqual(len(updates), 3)
+        self.assertFalse(updates[0].visible)
+        self.assertTrue(updates[1].visible)
+        self.assertFalse(updates[2].visible)
+
+    @unittest.mock.patch("gradio.update")
+    def test_update_input_visibility_base64(
+        self, mock_gr_update
+    ):  # Added mock_gr_update
+        mock_gr_update.side_effect = [
+            MockGradioUpdateReturn(visible=False),
+            MockGradioUpdateReturn(visible=False),
+            MockGradioUpdateReturn(visible=True),
+        ]
+        updates = update_input_visibility("Enter Base64")
+        self.assertEqual(len(updates), 3)
+        self.assertFalse(updates[0].visible)
+        self.assertFalse(updates[1].visible)
+        self.assertTrue(updates[2].visible)
+
+    @unittest.mock.patch("gradio.update")
+    def test_update_input_visibility_default(
+        self, mock_gr_update
+    ):  # Added mock_gr_update
+        mock_gr_update.side_effect = [
+            MockGradioUpdateReturn(visible=True),
+            MockGradioUpdateReturn(visible=False),
+            MockGradioUpdateReturn(visible=False),
+        ]
+        updates = update_input_visibility("Invalid Choice")
+        self.assertEqual(len(updates), 3)
+        self.assertTrue(updates[0].visible)
+        self.assertFalse(updates[1].visible)
+        self.assertFalse(updates[2].visible)
+
+
+if __name__ == "__main__":
+    unittest.main()

utils/face_detector.py

@@ -1,5 +1,6 @@
 import dlib
 
+
 def load_face_detector():
     """
     Loads the dlib face detector.

utils/image_utils.py

@@ -6,7 +6,7 @@ import urllib.request
 # Third-party imports
 from PIL import Image
 import numpy as np
-import cv2 # preprocess_image uses cv2.cvtColor, so it's needed here
+
 
 def load_image(image_path):
     """
@@ -50,12 +50,13 @@ def preprocess_image(image):
     """
     # Ensure image is a PIL Image before converting
     if not isinstance(image, Image.Image):
-         image = Image.fromarray(image)
+        image = Image.fromarray(image)
 
     image = image.convert("RGB")
     image = np.array(image)
     return image
 
+
 def get_image_from_input(input_type, uploaded_image, image_url, base64_string):
     """
     Centralized function to get an image from various input types.
@@ -73,31 +74,31 @@ def get_image_from_input(input_type, uploaded_image, image_url, base64_string):
     input_value = None
 
     if input_type == "Upload File" and uploaded_image is not None:
-        image = uploaded_image # This is a PIL Image from gr.Image(type="pil")
-        print("Using uploaded image (PIL)") # Debug print
+        image = uploaded_image  # This is a PIL Image from gr.Image(type="pil")
+        print("Using uploaded image (PIL)")  # Debug print
 
     elif input_type == "Enter URL" and image_url and image_url.strip():
         input_value = image_url
-        print(f"Using URL: {input_value}") # Debug print
+        print(f"Using URL: {input_value}")  # Debug print
 
     elif input_type == "Enter Base64" and base64_string and base64_string.strip():
         input_value = base64_string
-        print(f"Using Base64 string") # Debug print
+        print("Using Base64 string")  # Debug print
 
     else:
         print("No valid input provided based on selected type.")
-        return None # No valid input
+        return None  # No valid input
 
     # If input_value is set (URL or Base64), use the local load_image
     if input_value:
         image = load_image(input_value)
         if image is None:
             print("Error: Could not load image from provided input.")
-            return None # load_image failed
+            return None  # load_image failed
 
     # Now 'image' should be a PIL Image or None
     if image is None:
         print("Image is None after loading/selection.")
         return None
 
-    return image
+    return image

utils/ui_utils.py

@@ -1,6 +1,7 @@
 # Utility functions for UI components
 import gradio as gr
 
+
 def update_input_visibility(choice):
     """
     Returns updates to the visibility of input components based on the selected input method.
@@ -29,9 +30,9 @@ def update_input_visibility(choice):
             gr.update(visible=False),
             gr.update(visible=True),
         )
-    else: # Default or unexpected
-         return (
+    else:  # Default or unexpected
+        return (
             gr.update(visible=True),
             gr.update(visible=False),
             gr.update(visible=False),
-         )
+        )