feat: added resize image

mcp_server.py

@@ -5,6 +5,7 @@ from src.utils.visualize_image import visualize_base64_image
 from src.utils.generate_image import generate_image
 from src.utils.apply_filter import apply_filter
 from src.utils.add_text import add_text_to_image
+from src.utils.resize_image import resize_image
 
 mcp = FastMCP("Youtube Service")
 
@@ -27,6 +28,7 @@ mcp.add_tool(visualize_base64_image)
 mcp.add_tool(generate_image)
 mcp.add_tool(apply_filter)
 mcp.add_tool(add_text_to_image)
+mcp.add_tool(resize_image)
 
 if __name__ == "__main__":
     mcp.run()

src/utils/change_format.py

@@ -2,8 +2,9 @@ from PIL import Image
 from io import BytesIO
 import requests
 import base64
+from typing import Union
 
-def change_format(image_url: str, target_format: str) -> str:
+def change_format(image: Union[str, BytesIO], target_format: str) -> str:
     """
     Change the format of an image from a URL to the specified target format.
     
@@ -15,18 +16,30 @@ def change_format(image_url: str, target_format: str) -> str:
         The image converted to the target format as a base64-encoded string.
     """
     
-    response = requests.get(image_url, timeout=30)
-    response.raise_for_status()
+    if not isinstance(image, BytesIO):
+        response = requests.get(image, timeout=30)
+        response.raise_for_status()
     
-    # Open the image from bytes
-    img = Image.open(BytesIO(response.content))
+        # Open the image from bytes
+        img = Image.open(BytesIO(response.content))
     
     # Convert the image to the target format
-    output = BytesIO()
-    img.save(output, format=target_format)
-    output.seek(0)
-    
-    # Convert to base64 string for JSON serialization
-    encoded_image = base64.b64encode(output.getvalue()).decode('utf-8')
-    
-    return encoded_image  # Return base64 encoded string that can be serialized to JSON
+        output = BytesIO()
+        img.save(output, format=target_format)
+        output.seek(0)
+        
+        # Convert to base64 string for JSON serialization
+        encoded_image = base64.b64encode(output.getvalue()).decode('utf-8')
+        
+        return encoded_image  # Return base64 encoded string that can be serialized to JSON
+    else: 
+        img = Image.open(image)
+        
+        output = BytesIO()
+        img.save(output, format=target_format)
+        output.seek(0)
+        
+        # Convert to base64 string for JSON serialization
+        encoded_image = base64.b64encode(output.getvalue()).decode('utf-8')
+        
+        return encoded_image

src/utils/resize_image.py

@@ -0,0 +1,56 @@
+from PIL import Image
+from io import BytesIO
+import requests
+import base64
+from typing import Union, Tuple
+
+def resize_image(image_input: Union[str, BytesIO], target_size: Tuple[int, int], return_format: str = "base64") -> str:
+    """
+    Resize an image to the target size while maintaining aspect ratio.
+    
+    Args:
+        image_input: URL, file path, base64 string, or BytesIO object
+        target_size: Tuple (width, height) for the target size
+        return_format: Format to return the image in ("base64" or "pil")
+        
+    Returns:
+        Base64 encoded string of the resized image or PIL Image object
+    """
+    # Convert input to PIL Image
+    if isinstance(image_input, str):
+        if image_input.startswith(('http://', 'https://')):
+            # It's a URL
+            response = requests.get(image_input, timeout=10)
+            response.raise_for_status()
+            image = Image.open(BytesIO(response.content))
+        elif image_input.startswith('data:image'):
+            # It's a base64 data URI
+            base64_data = image_input.split(',')[1]
+            image = Image.open(BytesIO(base64.b64decode(base64_data)))
+        elif ';base64,' not in image_input and len(image_input) > 500:
+            # Likely a raw base64 string
+            image = Image.open(BytesIO(base64.b64decode(image_input)))
+        else:
+            # Assume it's a file path
+            image = Image.open(image_input)
+    elif isinstance(image_input, BytesIO):
+        image = Image.open(image_input)
+    else:
+        raise ValueError("Unsupported image input type")
+
+    # Calculate the aspect ratio
+    aspect_ratio = min(target_size[0] / image.width, target_size[1] / image.height)
+    
+    # Calculate new size
+    new_size = (int(image.width * aspect_ratio), int(image.height * aspect_ratio))
+    
+    # Resize the image using the proper resampling filter
+    resized_image = image.resize(new_size, Image.LANCZOS)
+    
+    # Return in requested format
+    if return_format.lower() == "base64":
+        buffer = BytesIO()
+        resized_image.save(buffer, format="PNG")
+        return base64.b64encode(buffer.getvalue()).decode('utf-8')
+    else:
+        return resized_image