Merge branch 'main' into test

mcp_server.py

@@ -2,6 +2,9 @@ from mcp.server.fastmcp import FastMCP
 from src.utils.change_format import change_format
 from src.utils.image_helpers import remove_background_from_url
 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
 
 mcp = FastMCP("Youtube Service")
 
@@ -21,6 +24,9 @@ def say_hello(name: str) -> str:
 mcp.add_tool(remove_background_from_url)
 mcp.add_tool(change_format)
 mcp.add_tool(visualize_base64_image)
+mcp.add_tool(generate_image)
+mcp.add_tool(apply_filter)
+mcp.add_tool(add_text_to_image)
 
 if __name__ == "__main__":
     mcp.run()

requirements.txt

@@ -2,4 +2,5 @@ fastmcp
 requests
 Pillow
 rembg
-onnxruntime
+onnxruntime
+openai

requirements_test.txt

@@ -0,0 +1,172 @@
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.7
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.9.0
+asgiref==3.8.1
+attrs==25.3.0
+audioop-lts==0.2.1
+Authlib==1.6.0
+backoff==2.2.1
+bcrypt==4.3.0
+beautifulsoup4==4.13.4
+bs4==0.0.2
+build==1.2.2.post1
+cachetools==5.5.2
+certifi==2025.4.26
+cffi==1.17.1
+charset-normalizer==3.4.2
+chromadb==1.0.12
+click==8.2.1
+coloredlogs==15.0.1
+cryptography==45.0.3
+dataclasses-json==0.6.7
+Deprecated==1.2.18
+distro==1.9.0
+durationpy==0.10
+exceptiongroup==1.3.0
+fastapi==0.115.9
+fastmcp==2.6.0
+ffmpy==0.6.0
+filelock==3.18.0
+flatbuffers==25.2.10
+frozenlist==1.6.0
+fsspec==2025.5.1
+google-auth==2.40.2
+googleapis-common-protos==1.70.0
+gradio==5.32.1
+gradio_client==1.10.2
+groovy==0.1.2
+grpcio==1.72.1
+h11==0.16.0
+hf-xet==1.1.2
+httpcore==1.0.9
+httptools==0.6.4
+httpx==0.28.1
+httpx-sse==0.4.0
+huggingface-hub==0.32.3
+humanfriendly==10.0
+idna==3.10
+imageio==2.37.0
+importlib_metadata==8.6.1
+importlib_resources==6.5.2
+Jinja2==3.1.6
+jiter==0.10.0
+joblib==1.5.1
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.24.0
+jsonschema-specifications==2025.4.1
+kubernetes==32.0.1
+langchain==0.3.25
+langchain-chroma==0.2.4
+langchain-community==0.3.24
+langchain-core==0.3.63
+langchain-huggingface==0.2.0
+langchain-text-splitters==0.3.8
+langsmith==0.3.44
+lazy_loader==0.4
+llvmlite==0.44.0
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+marshmallow==3.26.1
+mcp==1.9.2
+mdurl==0.1.2
+mmh3==5.1.0
+mpmath==1.3.0
+multidict==6.4.4
+mypy_extensions==1.1.0
+networkx==3.5
+numba==0.61.2
+numpy==2.2.6
+oauthlib==3.2.2
+onnxruntime==1.22.0
+openai==1.84.0
+openapi-pydantic==0.5.1
+opencv-python-headless==4.11.0.86
+opentelemetry-api==1.33.1
+opentelemetry-exporter-otlp-proto-common==1.33.1
+opentelemetry-exporter-otlp-proto-grpc==1.33.1
+opentelemetry-instrumentation==0.54b1
+opentelemetry-instrumentation-asgi==0.54b1
+opentelemetry-instrumentation-fastapi==0.54b1
+opentelemetry-proto==1.33.1
+opentelemetry-sdk==1.33.1
+opentelemetry-semantic-conventions==0.54b1
+opentelemetry-util-http==0.54b1
+orjson==3.10.18
+overrides==7.7.0
+packaging==24.2
+pandas==2.2.3
+pillow==11.2.1
+platformdirs==4.3.8
+pooch==1.8.2
+posthog==4.2.0
+propcache==0.3.1
+protobuf==5.29.5
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pycparser==2.22
+pydantic==2.11.5
+pydantic-settings==2.9.1
+pydantic_core==2.33.2
+pydub==0.25.1
+Pygments==2.19.1
+PyMatting==1.1.14
+PyPika==0.48.9
+pyproject_hooks==1.2.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.0
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.2
+referencing==0.36.2
+regex==2024.11.6
+rembg==2.0.66
+requests==2.32.3
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==14.0.0
+rpds-py==0.25.1
+rsa==4.9.1
+ruff==0.11.12
+safehttpx==0.1.6
+safetensors==0.5.3
+scikit-image==0.25.2
+scikit-learn==1.6.1
+scipy==1.15.3
+semantic-version==2.10.0
+sentence-transformers==4.1.0
+setuptools==80.9.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.7
+SQLAlchemy==2.0.41
+sse-starlette==2.3.6
+starlette==0.45.3
+sympy==1.14.0
+tenacity==9.1.2
+threadpoolctl==3.6.0
+tifffile==2025.6.1
+tokenizers==0.21.1
+tomlkit==0.13.2
+torch==2.7.0
+tqdm==4.67.1
+transformers==4.52.4
+typer==0.16.0
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+typing_extensions==4.14.0
+tzdata==2025.2
+urllib3==2.4.0
+uvicorn==0.34.3
+uvloop==0.21.0
+watchfiles==1.0.5
+websocket-client==1.8.0
+websockets==15.0.1
+wrapt==1.17.2
+yarl==1.20.0
+zipp==3.22.0
+zstandard==0.23.0

src/utils/add_text.py

@@ -0,0 +1,68 @@
+from PIL import Image, ImageDraw, ImageFont
+import os
+from typing import Optional, Tuple, Dict, Any
+
+def add_text_to_image(
+    image_path: str,
+    text: str,
+    color: Optional[Tuple[int, int, int]] = None,
+    output_name: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Adds centered text to an image and saves the result in the same folder.
+    If no output_name is provided, '_edited' is appended to the original filename.
+    If no color is provided, black is used by default.
+
+    Args:
+        image_path: Path to the original image.
+        text: Text to write on the image.
+        color: Optional RGB color of the text. Defaults to black.
+        output_name: Optional output filename (without extension).
+
+    Returns:
+        Dictionary with success status and info.
+    """
+    try:
+        if color is None:
+            color = (0, 0, 0)
+
+        image = Image.open(image_path)
+        draw = ImageDraw.Draw(image)
+        font = ImageFont.load_default()
+
+        text_width = draw.textlength(text, font=font)
+        x = (image.width - text_width) / 2
+        y = image.height / 2
+
+        draw.text((x, y), text, fill=color, font=font)
+
+        base_dir = os.path.dirname(image_path)
+        base_name, ext = os.path.splitext(os.path.basename(image_path))
+
+        if output_name:
+            new_filename = f"{output_name}{ext}"
+        else:
+            new_filename = f"{base_name}_edited{ext}"
+
+        new_path = os.path.join(base_dir, new_filename)
+
+        image.save(new_path)
+        output_size = os.path.getsize(new_path)
+
+        return {
+            "success": True,
+            "message": "Text added successfully to the image",
+            "input_path": image_path,
+            "output_path": new_path,
+            "output_size_bytes": output_size,
+            "text": text,
+            "color": color
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "input_path": image_path,
+            "output_path": None
+        }

src/utils/add_watermark.py

@@ -0,0 +1,56 @@
+from PIL import Image, ImageDraw, ImageFont
+import os
+from typing import Dict, Any
+
+def add_watermark(image_path: str, watermark_text: str) -> Dict[str, Any]:
+    try:
+        image = Image.open(image_path)
+        
+        overlay = Image.new('RGBA', image.size, (255, 255, 255, 0))
+        draw = ImageDraw.Draw(overlay)
+        
+        try:
+            font_size = min(image.width, image.height) // 20
+            font = ImageFont.truetype("arial.ttf", font_size)
+        except:
+            font = ImageFont.load_default()
+        
+        bbox = draw.textbbox((0, 0), watermark_text, font=font)
+        text_width = bbox[2] - bbox[0]
+        text_height = bbox[3] - bbox[1]
+        
+        x = (image.width - text_width) // 2
+        y = (image.height - text_height) // 2
+        
+        text_color = (255, 255, 255, 128)
+        
+        draw.text((x-2, y-2), watermark_text, fill=(0, 0, 0, 64), font=font)
+        draw.text((x, y), watermark_text, fill=text_color, font=font)
+        
+        watermarked = Image.alpha_composite(image.convert('RGBA'), overlay)
+        final_image = watermarked.convert('RGB')
+        
+        base_dir = os.path.dirname(image_path)
+        base_name, ext = os.path.splitext(os.path.basename(image_path))
+        new_filename = f"{base_name}_watermarked{ext}"
+        new_path = os.path.join(base_dir, new_filename)
+        
+        final_image.save(new_path, quality=95)
+        output_size = os.path.getsize(new_path)
+        
+        return {
+            "success": True,
+            "message": "Watermark added successfully",
+            "input_path": image_path,
+            "output_path": new_path,
+            "output_size_bytes": output_size,
+            "watermark_text": watermark_text
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "input_path": image_path,
+            "output_path": None
+        }

src/utils/apply_filter.py

@@ -0,0 +1,123 @@
+from PIL import Image, ImageFilter, ImageEnhance
+from io import BytesIO
+import requests
+import base64
+
+def apply_filter(image_url: str, filter_type: str, intensity: float = 1.0, output_format: str = 'JPEG') -> str:
+    """
+    Apply various filters to an image from a URL.
+    
+    Args:
+        image_url: The URL of the input image.
+        filter_type: Type of filter to apply ('blur', 'sharpen', 'emboss', 'edge', 'smooth', 
+                    'brightness', 'contrast', 'saturation', 'sepia', 'grayscale').
+        intensity: Filter intensity (0.1 to 3.0, default 1.0).
+        output_format: The desired output format (e.g., 'JPEG', 'PNG').
+        
+    Returns:
+        The filtered image as a base64-encoded string.
+    """
+    
+    response = requests.get(image_url, timeout=30)
+    response.raise_for_status()
+    
+    img = Image.open(BytesIO(response.content))
+    
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    
+    if filter_type == 'blur':
+        img = img.filter(ImageFilter.GaussianBlur(radius=intensity))
+    elif filter_type == 'sharpen':
+        img = img.filter(ImageFilter.UnsharpMask(radius=2, percent=int(intensity * 150), threshold=3))
+    elif filter_type == 'emboss':
+        img = img.filter(ImageFilter.EMBOSS)
+    elif filter_type == 'edge':
+        img = img.filter(ImageFilter.FIND_EDGES)
+    elif filter_type == 'smooth':
+        img = img.filter(ImageFilter.SMOOTH_MORE)
+    elif filter_type == 'brightness':
+        enhancer = ImageEnhance.Brightness(img)
+        img = enhancer.enhance(intensity)
+    elif filter_type == 'contrast':
+        enhancer = ImageEnhance.Contrast(img)
+        img = enhancer.enhance(intensity)
+    elif filter_type == 'saturation':
+        enhancer = ImageEnhance.Color(img)
+        img = enhancer.enhance(intensity)
+    elif filter_type == 'sepia':
+        img = apply_sepia_filter(img)
+    elif filter_type == 'grayscale':
+        img = img.convert('L').convert('RGB')
+    
+    output = BytesIO()
+    img.save(output, format=output_format, quality=95)
+    output.seek(0)
+    
+    encoded_image = base64.b64encode(output.getvalue()).decode('utf-8')
+    
+    return encoded_image
+
+def apply_sepia_filter(img: Image.Image) -> Image.Image:
+    """
+    Apply sepia tone effect to an image.
+    
+    Args:
+        img: PIL Image object.
+        
+    Returns:
+        Image with sepia effect applied.
+    """
+    
+    pixels = img.load()
+    width, height = img.size
+    
+    for y in range(height):
+        for x in range(width):
+            r, g, b = pixels[x, y]
+            
+            tr = int(0.393 * r + 0.769 * g + 0.189 * b)
+            tg = int(0.349 * r + 0.686 * g + 0.168 * b)
+            tb = int(0.272 * r + 0.534 * g + 0.131 * b)
+            
+            pixels[x, y] = (min(255, tr), min(255, tg), min(255, tb))
+    
+    return img
+
+def apply_vintage_filter(image_url: str, output_format: str = 'JPEG') -> str:
+    """
+    Apply a vintage effect combining multiple filters.
+    
+    Args:
+        image_url: The URL of the input image.
+        output_format: The desired output format.
+        
+    Returns:
+        The vintage-filtered image as a base64-encoded string.
+    """
+    
+    response = requests.get(image_url, timeout=30)
+    response.raise_for_status()
+    
+    img = Image.open(BytesIO(response.content))
+    
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    
+    contrast_enhancer = ImageEnhance.Contrast(img)
+    img = contrast_enhancer.enhance(0.8)
+    
+    brightness_enhancer = ImageEnhance.Brightness(img)
+    img = brightness_enhancer.enhance(1.1)
+    
+    img = apply_sepia_filter(img)
+    
+    img = img.filter(ImageFilter.GaussianBlur(radius=0.5))
+    
+    output = BytesIO()
+    img.save(output, format=output_format, quality=90)
+    output.seek(0)
+    
+    encoded_image = base64.b64encode(output.getvalue()).decode('utf-8')
+    
+    return encoded_image

src/utils/generate_image.py

@@ -0,0 +1,85 @@
+import os
+import base64
+from typing import Dict, Any
+from openai import OpenAI
+
+async def generate_image(
+    prompt: str,
+    output_path: str = "generated_image.png",
+    width: int = 1024,
+    height: int = 1024,
+    num_inference_steps: int = 28,
+    negative_prompt: str = "",
+    seed: int = -1
+) -> Dict[str, Any]:
+    """
+    Generate an image using Nebius API.
+    
+    Args:
+        prompt: Text prompt for image generation
+        output_path: Path where to save the generated image
+        width: Image width
+        height: Image height
+        num_inference_steps: Number of inference steps
+        negative_prompt: Negative prompt for generation
+        seed: Random seed (-1 for random)
+    
+    Returns:
+        Dictionary with result information
+    """
+
+    try:
+        client = OpenAI(
+            base_url="https://api.studio.nebius.com/v1/",
+            api_key=os.environ.get("NEBIUS_API_KEY")
+        )
+        
+        response = client.images.generate(
+            model="black-forest-labs/flux-dev",
+            response_format="b64_json",
+            extra_body={
+                "response_extension": "png",
+                "width": width,
+                "height": height,
+                "num_inference_steps": num_inference_steps,
+                "negative_prompt": negative_prompt,
+                "seed": seed
+            },
+            prompt=prompt
+        )
+        
+        image_data = base64.b64decode(response.data[0].b64_json)
+        
+        with open(output_path, 'wb') as output_file:
+            output_file.write(image_data)
+        
+        output_size = os.path.getsize(output_path)
+        
+        return {
+            "success": True,
+            "message": "Image generated successfully",
+            "prompt": prompt,
+            "output_path": output_path,
+            "output_size_bytes": output_size,
+            "generation_params": {
+                "width": width,
+                "height": height,
+                "num_inference_steps": num_inference_steps,
+                "negative_prompt": negative_prompt,
+                "seed": seed
+            }
+        }
+        
+    except Exception as e:
+        if "NEBIUS_API_KEY" in str(e) or not os.environ.get("NEBIUS_API_KEY"):
+            return {
+                "success": False,
+                "error": "NEBIUS_API_KEY environment variable not set",
+                "output_path": None,
+                'user': os.environ.get("USER")
+            }
+        return {
+            "success": False,
+            "error": f"Failed to generate image: {str(e)}",
+            "output_path": None
+        }