image converter added

.gitignore

@@ -0,0 +1,3 @@
+venv
+.env
+image/__pycache__

Dockerfile

@@ -0,0 +1,32 @@
+# Use official Python image
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git libheif-dev pkg-config \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create user (Hugging Face Spaces requirement)
+RUN useradd -m -u 1000 user
+
+# Switch to user early
+USER user
+
+# Set working directory
+WORKDIR /home/user/app
+
+# Set environment variables for Hugging Face Spaces
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    BASE_PATH=/home/user/app \
+    IS_DOCKER=True \
+    SERVER_PORT=7860
+
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+# Copy app code
+COPY --chown=user . .
+
+# Entry point
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

image/converter.py

@@ -0,0 +1,266 @@
+"""
+High-Quality Image Converter Module
+
+This module provides a class-based image converter that preserves original quality
+and aspect ratio during format conversion. Supports all major image formats.
+"""
+
+from .image_base import ImageBase
+from PIL import Image
+import os
+from typing import Dict, Optional, Tuple
+from custom_logger import logger_config
+import pillow_heif
+pillow_heif.register_heif_opener()
+
+
+class Converter(ImageBase):
+    """
+    High-quality image format converter that preserves original quality and aspect ratio.
+    
+    This class handles conversion between various image formats while maintaining
+    the highest possible quality and exact dimensional preservation.
+    """
+    def __init__(self):
+        super().__init__("converter")
+    
+    def _validate_output_format(self, output_format: str) -> str:
+        """
+        Validate and normalize the output format.
+        
+        Args:
+            output_format: Desired output format
+            
+        Returns:
+            Normalized PIL format name
+            
+        Raises:
+            ValueError: If format is not supported
+        """
+        if not output_format or not output_format.strip():
+            raise ValueError("Output format cannot be empty")
+            
+        format_clean = output_format.lower().strip()
+        
+        if format_clean not in self.supported_formats:
+            supported_list = ', '.join(self.supported_formats.keys())
+            raise ValueError(f"Unsupported format '{output_format}'. Supported: {supported_list}")
+            
+        return self.supported_formats[format_clean]
+    
+    def _get_optimal_save_settings(self, format_name: str) -> Dict:
+        """
+        Get optimal save settings for maximum quality preservation.
+        
+        Args:
+            format_name: PIL format name (e.g., 'JPEG', 'PNG')
+            
+        Returns:
+            Dictionary of save settings for the format
+        """
+        settings = {}
+        
+        if format_name == 'JPEG':
+            settings = {
+                'quality': 100,        # Maximum quality
+                'optimize': False,     # Don't optimize (can reduce quality)
+                'progressive': False,  # Standard baseline JPEG
+                'subsampling': 0       # No chroma subsampling (4:4:4)
+            }
+            
+        elif format_name == 'PNG':
+            settings = {
+                'optimize': False,     # Don't optimize to preserve exact quality
+                'compress_level': 1    # Minimal compression for maximum quality
+            }
+            
+        elif format_name == 'WEBP':
+            settings = {
+                'lossless': True,      # Lossless compression
+                'quality': 100,        # Maximum quality (for fallback)
+                'method': 6            # Best compression method
+            }
+            
+        elif format_name == 'TIFF':
+            settings = {
+                'compression': None    # No compression for perfect quality
+            }
+            
+        elif format_name == 'BMP':
+            settings = {}  # BMP is always lossless
+            
+        elif format_name == 'GIF':
+            settings = {
+                'optimize': False      # Don't optimize palette
+            }
+            
+        return settings
+    
+    def _preserve_metadata(self, original_image: Image.Image, format_name: str) -> Dict:
+        """
+        Extract metadata from original image that's compatible with target format.
+        
+        Args:
+            original_image: Original PIL Image object
+            format_name: Target PIL format name
+            
+        Returns:
+            Dictionary of metadata to preserve
+        """
+        metadata = {}
+        
+        if not hasattr(original_image, 'info') or not original_image.info:
+            return metadata
+            
+        # DPI preservation
+        if 'dpi' in original_image.info and format_name in ['JPEG', 'PNG', 'TIFF', 'WEBP']:
+            metadata['dpi'] = original_image.info['dpi']
+            
+        # Color profile preservation  
+        if 'icc_profile' in original_image.info and format_name in ['JPEG', 'PNG', 'TIFF', 'WEBP']:
+            metadata['icc_profile'] = original_image.info['icc_profile']
+            
+        # EXIF data preservation
+        if 'exif' in original_image.info and format_name in ['JPEG', 'TIFF', 'WEBP']:
+            metadata['exif'] = original_image.info['exif']
+            
+        return metadata
+    
+    def _convert_color_mode(self, image: Image.Image, target_format: str) -> Image.Image:
+        """
+        Convert image color mode if required by target format, preserving quality.
+        
+        Args:
+            image: PIL Image object
+            target_format: Target PIL format name
+            
+        Returns:
+            Image with appropriate color mode
+        """
+        # Create exact copy to preserve original
+        converted_image = image.copy()
+        
+        # Handle formats that don't support transparency
+        if target_format == 'JPEG' and converted_image.mode in ('RGBA', 'LA', 'P'):
+            logger_config.info("Converting to RGB (JPEG doesn't support transparency)")
+            
+            if converted_image.mode == 'P':
+                # Preserve palette colors during conversion
+                converted_image = converted_image.convert('RGBA')
+            
+            # Create white background and blend with perfect quality
+            background = Image.new("RGB", converted_image.size, (255, 255, 255))
+            if converted_image.mode in ('RGBA', 'LA'):
+                # Use alpha_composite for perfect quality preservation
+                bg_rgba = background.convert('RGBA')
+                composite = Image.alpha_composite(bg_rgba, converted_image.convert('RGBA'))
+                converted_image = composite.convert('RGB')
+                
+        elif target_format == 'BMP' and converted_image.mode in ('RGBA', 'LA'):
+            logger_config.info("Converting to RGB (BMP doesn't support transparency)")
+            background = Image.new("RGB", converted_image.size, (255, 255, 255))
+            bg_rgba = background.convert('RGBA')
+            composite = Image.alpha_composite(bg_rgba, converted_image.convert('RGBA'))
+            converted_image = composite.convert('RGB')
+            
+        return converted_image
+    
+    def _verify_conversion_quality(self, original_size: Tuple[int, int], output_path: str) -> bool:
+        """
+        Verify that the converted image maintains original quality and dimensions.
+        
+        Args:
+            original_size: Original image dimensions (width, height)
+            output_path: Path to converted image
+            
+        Returns:
+            True if verification passes
+            
+        Raises:
+            Exception: If verification fails
+        """
+        if not os.path.exists(output_path):
+            raise Exception("Output file was not created")
+            
+        # Check file size
+        file_size = os.path.getsize(output_path)
+        logger_config.info(f"✓ Output file created: {file_size:,} bytes")
+        
+        # Verify dimensions are preserved
+        with Image.open(output_path) as verify_img:
+            if verify_img.size != original_size:
+                raise Exception(f"Dimensions changed! Expected: {original_size}, Got: {verify_img.size}")
+            
+            logger_config.info(f"✓ Aspect ratio preserved: {verify_img.size}")
+            
+        return True
+    
+    def convert_image(self, input_file_name: str, output_format: str) -> str:
+        """
+        Convert an image to the specified format with maximum quality and ratio preservation.
+        
+        Args:
+            input_file: Path to the input image file
+            output_format: Target image format
+            
+        Returns:
+            Path to the converted output file
+            
+        Raises:
+            FileNotFoundError: If input file doesn't exist
+            ValueError: If parameters are invalid
+            Exception: If conversion fails
+        """
+        try:
+            # Validate inputs
+            self.input_file_name = input_file_name
+            self.input_file_path = f'{self.input_dir}/{self.input_file_name}'
+            self._validate_input_file()
+            target_format = self._validate_output_format(output_format)
+            
+            logger_config.info(f"Starting conversion: {self.input_file_path}")
+            
+            # Open and analyze original image
+            with Image.open(self.input_file_path) as original_image:
+                original_size = original_image.size
+                original_mode = original_image.mode
+                original_format = original_image.format
+                
+                logger_config.info(f"Original - Format: {original_format}, Mode: {original_mode}, Size: {original_size}")
+                
+                # Convert color mode if necessary
+                converted_image = self._convert_color_mode(original_image, target_format)
+                
+                # Verify size preservation (safety check)
+                if converted_image.size != original_size:
+                    raise Exception(f"Size changed during conversion! Original: {original_size}, Current: {converted_image.size}")
+                
+                # Generate output path
+                output_path = self._generate_output_path(output_format)
+                
+                # Get optimal save settings
+                save_settings = self._get_optimal_save_settings(target_format)
+                
+                # Preserve metadata
+                metadata = self._preserve_metadata(original_image, target_format)
+                save_settings.update(metadata)
+                
+                logger_config.info(f"Converting to {target_format} with maximum quality")
+                
+                # Perform conversion with quality preservation
+                converted_image.save(output_path, format=target_format, **save_settings)
+                
+                # Verify conversion quality
+                self._verify_conversion_quality(original_size, output_path)
+
+                logger_config.info(f"✓ Conversion completed successfully: {output_path}")
+                return output_path
+                
+        except Exception as e:
+            logger_config.info(f"Image conversion failed: {str(e)}")
+            return None
+
+# Example usage
+if __name__ == "__main__":
+    converter = Converter()
+    converter.convert_image("image/test.HEIC", "png")

image/image_base.py

@@ -0,0 +1,134 @@
+import os
+import json
+from datetime import datetime, timedelta
+from process_exception import ProcessAlreadyRunning
+from main_base import MainBase
+from pathlib import Path
+
+class ImageBase(MainBase):
+	def __init__(self, feature=None, process_id="process_id"):
+		super().__init__()
+		self.current_path = os.path.abspath(os.path.join(os.path.dirname(__file__)))
+		self.feature = feature
+		self.process_id = process_id
+		self.input_dir = os.path.join(self.current_path, "input")
+		self.output_dir = os.path.join(self.current_path, "output")
+		self.process = os.path.join(self.current_path, "process.json")
+		self.supported_formats = {
+			'jpg': 'JPEG',
+			'jpeg': 'JPEG', 
+			'png': 'PNG',
+			'webp': 'WEBP',
+			'tiff': 'TIFF',
+			'tif': 'TIFF',
+			'bmp': 'BMP',
+			'gif': 'GIF',
+			'heic': 'HEIC'
+		}
+
+		# Create directories if they don't exist
+		os.makedirs(self.input_dir, exist_ok=True)
+		os.makedirs(self.output_dir, exist_ok=True)
+
+	def _validate_input_file(self, image=None):
+		"""
+		Validate that the input file exists and is a supported image format.
+		Args:
+			image: UploadFile object (for upload case)
+		Raises:
+			FileNotFoundError: If input file doesn't exist
+			ValueError: If file format is not supported
+		"""
+		if image:
+			# Handle upload case
+			if not image.filename:
+				raise ValueError("Uploaded file must have a filename")
+			
+			extension = Path(image.filename).suffix.lower().lstrip('.')
+		else:
+			# Handle file path case
+			if not self.input_file_path or not self.input_file_path.strip():
+				raise ValueError("Image path cannot be empty")
+			
+			path_obj = Path(self.input_file_path)
+			if not path_obj.exists():
+				raise FileNotFoundError(f"Image file not found: {self.input_file_path}")
+			
+			if not path_obj.is_file():
+				raise ValueError(f"Path is not a file: {self.input_file_path}")
+			
+			extension = path_obj.suffix.lower().lstrip('.')
+
+		# Check if extension is supported
+		if extension not in self.supported_formats:
+			supported_list = ', '.join(self.supported_formats.keys())
+			raise ValueError(f"Unsupported format '{extension}'. Supported: {supported_list}")
+
+	def upload_validate(self, image):
+		super().upload_validate(image)
+		self._validate_input_file(image=image)
+
+
+	# def _is_already_running(self):
+	# 	try:
+	# 		if os.path.exists(self.process):
+	# 			with open(self.process, 'r') as file:
+	# 				json_data = json.load(file)
+
+	# 			if "start_time" in json_data and "end_time" not in json_data:
+	# 				start_time = datetime.fromisoformat(json_data["start_time"])
+	# 				time_diff = datetime.now() - start_time
+
+	# 				if time_diff > timedelta(minutes=5000):
+	# 					raise ProcessAlreadyRunning(
+	# 						message=(
+	# 							f"A process named '{json_data['feature']}' is already running. "
+	# 							f"Started At: {json_data['start_time']} "
+	# 							f"(Running for {time_diff.total_seconds() // 60:.1f} minutes)"
+	# 						),
+	# 						data=json_data
+	# 					)
+	# 	except: pass
+	# 	return True
+
+
+	# def _reset(self):
+	# 	if os.path.exists(self.process):
+	# 		os.remove(self.process)
+
+	# 	if os.path.exists(self.output_dir):
+	# 		for filename in os.listdir(self.output_dir):
+	# 			file_path = os.path.join(self.output_dir, filename)
+	# 			if os.path.isfile(file_path):
+	# 				os.remove(file_path)
+
+	# def _create_process(self):
+	# 	process_data = {
+	# 		"start_time": datetime.now().isoformat(),
+	# 		"feature": self.feature,
+	# 		"process_id": self.process_id
+	# 	}
+	# 	with open(self.process, 'w') as file:
+	# 		json.dump(process_data, file, indent=4)
+
+	# def __enter__(self):
+	# 	return self
+
+	# def __exit__(self, exc_type, exc_val, exc_tb):
+	# 	self.cleanup()
+
+	# def __del__(self):
+	# 	self.cleanup()
+
+	# def cleanup(self):
+	# 	try:
+	# 		if os.path.exists(self.process):
+	# 			with open(self.process, 'r') as file:
+	# 				json_data = json.load(file)
+
+	# 			json_data["end_time"] = datetime.now().isoformat()
+
+	# 			with open(self.process, 'w') as file:
+	# 				json.dump(json_data, file, indent=4)
+	# 	except Exception as e:
+	# 		print(f"[Process cleanup Error] {e}")

image/index.html

@@ -0,0 +1,918 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Image Convert - Tools Collection</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1000px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
+            overflow: hidden;
+        }
+
+        .header {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 40px 30px;
+            text-align: center;
+            position: relative;
+        }
+
+        .back-button {
+            position: absolute;
+            left: 30px;
+            top: 50%;
+            transform: translateY(-50%);
+            background: rgba(255, 255, 255, 0.2);
+            color: white;
+            border: none;
+            padding: 12px 20px;
+            border-radius: 50px;
+            cursor: pointer;
+            font-size: 1rem;
+            transition: all 0.3s ease;
+            text-decoration: none;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .back-button:hover {
+            background: rgba(255, 255, 255, 0.3);
+            transform: translateY(-50%) translateX(-2px);
+        }
+
+        .header-content {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 20px;
+            margin-bottom: 20px;
+        }
+
+        .header-text h1 {
+            font-size: 2.5rem;
+            margin-bottom: 10px;
+            font-weight: 300;
+        }
+
+        .header-text p {
+            font-size: 1.1rem;
+            opacity: 0.9;
+        }
+
+        .content {
+            padding: 40px;
+        }
+
+        .upload-section {
+            background: #f8f9fa;
+            border-radius: 15px;
+            padding: 40px;
+            text-align: center;
+            margin-bottom: 30px;
+            border: 2px dashed #dee2e6;
+            transition: all 0.3s ease;
+            cursor: pointer;
+        }
+
+        .upload-section:hover {
+            border-color: #667eea;
+            background: #f0f4ff;
+        }
+
+        .upload-section.dragover {
+            border-color: #667eea;
+            background: #e8f2ff;
+            transform: scale(1.02);
+        }
+
+        .upload-icon {
+            font-size: 4rem;
+            color: #667eea;
+            margin-bottom: 20px;
+            display: block;
+        }
+
+        .upload-text h3 {
+            color: #495057;
+            margin-bottom: 10px;
+            font-size: 1.5rem;
+        }
+
+        .upload-text p {
+            color: #6c757d;
+            margin-bottom: 20px;
+        }
+
+        .upload-button {
+            background: linear-gradient(135deg, #667eea, #764ba2);
+            color: white;
+            border: none;
+            padding: 15px 30px;
+            border-radius: 50px;
+            font-size: 1.1rem;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            box-shadow: 0 4px 15px rgba(102, 126, 234, 0.3);
+        }
+
+        .upload-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(102, 126, 234, 0.4);
+        }
+
+        .file-input {
+            display: none;
+        }
+
+        .settings-section {
+            background: white;
+            border-radius: 15px;
+            padding: 30px;
+            margin-bottom: 30px;
+            border: 1px solid #e9ecef;
+        }
+
+        .settings-title {
+            color: #495057;
+            font-size: 1.3rem;
+            margin-bottom: 20px;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .settings-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 20px;
+        }
+
+        .setting-group {
+            display: flex;
+            flex-direction: column;
+            gap: 8px;
+        }
+
+        .setting-label {
+            color: #495057;
+            font-weight: 500;
+            font-size: 0.95rem;
+        }
+
+        .setting-input {
+            padding: 12px 15px;
+            border: 2px solid #e9ecef;
+            border-radius: 10px;
+            font-size: 1rem;
+            transition: all 0.3s ease;
+        }
+
+        .setting-input:focus {
+            outline: none;
+            border-color: #667eea;
+            box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+        }
+
+        .files-preview {
+            margin-top: 30px;
+        }
+
+        .preview-title {
+            color: #495057;
+            font-size: 1.3rem;
+            margin-bottom: 20px;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .files-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+            gap: 20px;
+        }
+
+        .file-card {
+            background: white;
+            border-radius: 12px;
+            padding: 20px;
+            border: 1px solid #e9ecef;
+            transition: all 0.3s ease;
+            position: relative;
+        }
+
+        .file-card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 20px rgba(0, 0, 0, 0.1);
+        }
+
+        .file-preview {
+            width: 100%;
+            height: 120px;
+            background: #f8f9fa;
+            border-radius: 8px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            margin-bottom: 15px;
+            overflow: hidden;
+        }
+
+        .file-preview img {
+            max-width: 100%;
+            max-height: 100%;
+            object-fit: cover;
+            border-radius: 8px;
+        }
+
+        .file-icon {
+            font-size: 2rem;
+            color: #667eea;
+        }
+
+        .file-info h4 {
+            color: #495057;
+            font-size: 0.9rem;
+            margin-bottom: 5px;
+            word-break: break-all;
+        }
+
+        .file-info p {
+            color: #6c757d;
+            font-size: 0.8rem;
+            margin-bottom: 10px;
+        }
+
+        .file-status {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            margin-bottom: 10px;
+        }
+
+        .status-indicator {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: #28a745;
+        }
+
+        .status-indicator.processing {
+            background: #ffc107;
+            animation: pulse 2s infinite;
+        }
+
+        .status-indicator.error {
+            background: #dc3545;
+        }
+
+        .remove-button {
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            background: #dc3545;
+            color: white;
+            border: none;
+            width: 24px;
+            height: 24px;
+            border-radius: 50%;
+            cursor: pointer;
+            font-size: 0.8rem;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            transition: all 0.3s ease;
+        }
+
+        .remove-button:hover {
+            background: #c82333;
+            transform: scale(1.1);
+        }
+
+        .progress-section {
+            margin-top: 30px;
+            display: none;
+        }
+
+        .progress-title {
+            color: #495057;
+            font-size: 1.2rem;
+            margin-bottom: 15px;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .progress-bar-container {
+            background: #e9ecef;
+            border-radius: 10px;
+            height: 12px;
+            overflow: hidden;
+            margin-bottom: 10px;
+        }
+
+        .progress-bar {
+            background: linear-gradient(135deg, #28a745, #20c997);
+            height: 100%;
+            width: 0%;
+            transition: width 0.3s ease;
+            border-radius: 10px;
+        }
+
+        .progress-text {
+            color: #6c757d;
+            font-size: 0.9rem;
+            text-align: center;
+        }
+
+        .action-buttons {
+            display: flex;
+            gap: 15px;
+            justify-content: center;
+            margin-top: 30px;
+        }
+
+        .action-button {
+            padding: 15px 30px;
+            border: none;
+            border-radius: 50px;
+            font-size: 1.1rem;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            min-width: 150px;
+            justify-content: center;
+        }
+
+        .convert-button {
+            background: linear-gradient(135deg, #28a745, #20c997);
+            color: white;
+            box-shadow: 0 4px 15px rgba(40, 167, 69, 0.3);
+        }
+
+        .convert-button:hover:not(:disabled) {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(40, 167, 69, 0.4);
+        }
+
+        .convert-button:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+        }
+
+        .clear-button {
+            background: #6c757d;
+            color: white;
+        }
+
+        .clear-button:hover {
+            background: #5a6268;
+            transform: translateY(-2px);
+        }
+
+        .download-button {
+            background: linear-gradient(135deg, #007bff, #0056b3);
+            color: white;
+            box-shadow: 0 4px 15px rgba(0, 123, 255, 0.3);
+        }
+
+        .download-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(0, 123, 255, 0.4);
+        }
+
+        .error-message {
+            background: #f8d7da;
+            color: #721c24;
+            padding: 15px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+            border: 1px solid #f5c6cb;
+            display: none;
+        }
+
+        .success-message {
+            background: #d4edda;
+            color: #155724;
+            padding: 15px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+            border: 1px solid #c3e6cb;
+            display: none;
+        }
+
+        @keyframes pulse {
+            0% {
+                transform: scale(1);
+                opacity: 1;
+            }
+
+            50% {
+                transform: scale(1.05);
+                opacity: 0.8;
+            }
+
+            100% {
+                transform: scale(1);
+                opacity: 1;
+            }
+        }
+
+        @media (max-width: 768px) {
+            .header-content {
+                flex-direction: column;
+                gap: 15px;
+            }
+
+            .header-text h1 {
+                font-size: 2rem;
+            }
+
+            .back-button {
+                position: static;
+                transform: none;
+                margin-bottom: 20px;
+                align-self: flex-start;
+            }
+
+            .content {
+                padding: 20px;
+            }
+
+            .action-buttons {
+                flex-direction: column;
+                align-items: center;
+            }
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <div class="header">
+            <a href="/" class="back-button">
+                ← Back to Tools
+            </a>
+
+            <div class="header-content">
+                <div class="header-text">
+                    <h1>Image Convert</h1>
+                    <p>Convert HEIC images to PNG/JPG format with ease</p>
+                </div>
+            </div>
+        </div>
+
+        <div class="content">
+            <div class="error-message" id="error-message"></div>
+            <div class="success-message" id="success-message"></div>
+
+            <div class="upload-section" id="upload-section">
+                <span class="upload-icon">📁</span>
+                <div class="upload-text">
+                    <h3>Drop your images here</h3>
+                    <p>Support for HEIC, PNG, JPG, and more formats</p>
+                    <!-- <button class="upload-button" onclick="document.getElementById('file-input').click()"> -->
+                    <button class="upload-button">
+                        Choose Files
+                    </button>
+                </div>
+                <input type="file" id="file-input" class="file-input" multiple accept="image/*">
+            </div>
+
+            <div class="settings-section">
+                <h3 class="settings-title">
+                    ⚙️ Conversion Settings
+                </h3>
+                <div class="settings-grid">
+                    <div class="setting-group">
+                        <label class="setting-label">Output Format</label>
+                        <select class="setting-input" id="output-format">
+                            <option value="jpg">JPG</option>
+                            <option value="png">PNG</option>
+                            <option value="webp">WebP</option>
+                        </select>
+                    </div>
+                </div>
+            </div>
+
+            <div class="files-preview" id="files-preview" style="display: none;">
+                <h3 class="preview-title">
+                    📋 Selected Files
+                </h3>
+                <div class="files-grid" id="files-grid">
+                    <!-- File cards will be inserted here -->
+                </div>
+            </div>
+
+            <div class="progress-section" id="progress-section">
+                <h3 class="progress-title">
+                    🔄 Converting Images...
+                </h3>
+                <div class="progress-bar-container">
+                    <div class="progress-bar" id="progress-bar"></div>
+                </div>
+                <div class="progress-text" id="progress-text">0% complete</div>
+            </div>
+
+            <div class="action-buttons">
+                <button class="action-button convert-button" id="convert-button" disabled>
+                    🔄 Convert Images
+                </button>
+                <button class="action-button clear-button" id="clear-button">
+                    🗑️ Clear All
+                </button>
+                <button class="action-button download-button" id="download-button" style="display: none;">
+                    💾 Download All
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let selectedFiles = [];
+        let convertedFiles = [];
+
+        // Initialize the application
+        document.addEventListener('DOMContentLoaded', function () {
+            setupEventListeners();
+        });
+
+        function setupEventListeners() {
+            const uploadSection = document.getElementById('upload-section');
+            const fileInput = document.getElementById('file-input');
+            const convertButton = document.getElementById('convert-button');
+            const clearButton = document.getElementById('clear-button');
+            const downloadButton = document.getElementById('download-button');
+
+            // File upload events
+            uploadSection.addEventListener('click', () => fileInput.click());
+            uploadSection.addEventListener('dragover', handleDragOver);
+            uploadSection.addEventListener('dragleave', handleDragLeave);
+            uploadSection.addEventListener('drop', handleDrop);
+            fileInput.addEventListener('change', handleFileSelect);
+
+            // Button events
+            convertButton.addEventListener('click', convertImages);
+            clearButton.addEventListener('click', clearAllFiles);
+            downloadButton.addEventListener('click', downloadAllFiles);
+        }
+
+        function showMessage(message, type = 'error') {
+            const errorMsg = document.getElementById('error-message');
+            const successMsg = document.getElementById('success-message');
+
+            // Hide both messages first
+            errorMsg.style.display = 'none';
+            successMsg.style.display = 'none';
+
+            if (type === 'error') {
+                errorMsg.textContent = message;
+                errorMsg.style.display = 'block';
+            } else {
+                successMsg.textContent = message;
+                successMsg.style.display = 'block';
+            }
+
+            // Auto-hide after 5 seconds
+            setTimeout(() => {
+                errorMsg.style.display = 'none';
+                successMsg.style.display = 'none';
+            }, 5000);
+        }
+
+        function handleDragOver(e) {
+            e.preventDefault();
+            e.currentTarget.classList.add('dragover');
+        }
+
+        function handleDragLeave(e) {
+            e.preventDefault();
+            e.currentTarget.classList.remove('dragover');
+        }
+
+        function handleDrop(e) {
+            e.preventDefault();
+            const uploadSection = e.currentTarget;
+            uploadSection.classList.remove('dragover');
+
+            const files = Array.from(e.dataTransfer.files);
+            processFiles(files);
+        }
+
+        function handleFileSelect(e) {
+            const files = Array.from(e.target.files);
+            processFiles(files);
+        }
+
+        function generateUniqueId(file, length = 12) {
+            ext = "." + file.name.split(".")[file.name.split(".").length - 1]
+            const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+            return Array.from({ length }, () => chars[Math.floor(Math.random() * chars.length)]).join('') + ext;
+        }
+
+        function saveFileIdToStorage(id) {
+            let fileIds = JSON.parse(localStorage.getItem('uploadedFileIds') || '[]');
+            if (!fileIds.includes(id)) {
+                fileIds.push(id);
+                localStorage.setItem('uploadedFileIds', JSON.stringify(fileIds));
+            }
+        }
+
+        function processFiles(files) {
+            files.forEach((file, index) => {
+                const id = generateUniqueId(file); // generate unique ID
+                const fileData = {
+                    id: id,
+                    file: file,
+                    name: file.name,
+                    size: formatFileSize(file.size),
+                    status: 'ready',
+                    preview: null
+                };
+
+                // Store file ID in localStorage for potential server deletion later
+                saveFileIdToStorage(id);
+
+                // Create preview for images
+                const reader = new FileReader();
+                reader.onload = (e) => {
+                    fileData.preview = e.target.result;
+                    updateFileCard(fileData.id);
+                };
+                reader.readAsDataURL(file);
+
+                selectedFiles.push(fileData);
+            });
+
+            updateUI();
+        }
+
+        function updateUI() {
+            const filesPreview = document.getElementById('files-preview');
+            const convertButton = document.getElementById('convert-button');
+
+            if (selectedFiles.length > 0) {
+                filesPreview.style.display = 'block';
+                convertButton.disabled = false;
+                renderFileCards();
+            } else {
+                filesPreview.style.display = 'none';
+                convertButton.disabled = true;
+            }
+        }
+
+        function renderFileCards() {
+            const filesGrid = document.getElementById('files-grid');
+
+            filesGrid.innerHTML = selectedFiles.map(file => `
+                <div class="file-card" id="file-${file.id}">
+                    <button class="remove-button" onclick="removeFile('${file.id}')">×</button>
+                    
+                    <div class="file-preview">
+                        ${file.preview ?
+                    `<img src="${file.preview}" alt="${file.name}">` :
+                    '<span class="file-icon">🖼️</span>'
+                }
+                    </div>
+                    
+                    <div class="file-info">
+                        <h4>${file.name}</h4>
+                        <p>${file.size}</p>
+                        
+                        <div class="file-status">
+                            <div class="status-indicator ${file.status === 'processing' ? 'processing' : file.status === 'error' ? 'error' : ''}"></div>
+                            <span>${getStatusText(file.status)}</span>
+                        </div>
+                    </div>
+                </div>
+            `).join('');
+        }
+
+        function updateFileCard(fileId) {
+            const file = selectedFiles.find(f => f.id === fileId);
+            if (!file) return;
+
+            const card = document.getElementById(`file-${fileId}`);
+            if (!card) return;
+
+            const preview = card.querySelector('.file-preview');
+            if (file.preview && preview) {
+                preview.innerHTML = `<img src="${file.preview}" alt="${file.name}">`;
+            }
+        }
+
+        function removeFile(fileId) {
+            selectedFiles = selectedFiles.filter(file => file.id !== fileId);
+            convertedFiles = convertedFiles.filter(file => file.id !== fileId);
+            updateUI();
+
+            if (selectedFiles.length === 0) {
+                document.getElementById('download-button').style.display = 'none';
+            }
+        }
+
+        async function clearAllFiles() {
+            const fileIds = JSON.parse(localStorage.getItem('uploadedFileIds') || '[]');
+
+            if (fileIds.length > 0) {
+                try {
+                    await fetch('/image/delete', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({ ids: fileIds })
+                    });
+                } catch (err) {
+                    console.error('Error sending delete request:', err);
+                }
+            }
+
+            // Clear everything locally
+            selectedFiles = [];
+            convertedFiles = [];
+            updateUI();
+            document.getElementById('download-button').style.display = 'none';
+            document.getElementById('progress-section').style.display = 'none';
+            localStorage.removeItem('uploadedFileIds');
+        }
+
+
+        async function convertImages() {
+            if (selectedFiles.length === 0) return;
+
+            const progressSection = document.getElementById('progress-section');
+            const progressBar = document.getElementById('progress-bar');
+            const progressText = document.getElementById('progress-text');
+            const convertButton = document.getElementById('convert-button');
+
+            // Show progress section
+            progressSection.style.display = 'block';
+            convertButton.disabled = true;
+            convertButton.innerHTML = '🔄 Converting...';
+
+            const settings = getConversionSettings();
+            convertedFiles = [];
+
+            for (let i = 0; i < selectedFiles.length; i++) {
+                const file = selectedFiles[i];
+
+                // Update file status
+                file.status = 'uploading';
+                renderFileCards();
+
+                try {
+                    // Upload and convert the file
+                    await upload(file, settings);
+                    file.status = 'converting';
+                    renderFileCards();
+                    const convertedFile = await convert(file, settings);
+                    file.status = 'completed';
+                    renderFileCards();
+                    convertedFiles.push(convertedFile);
+                } catch (error) {
+                    console.error('Conversion error:', error);
+                    file.status = 'error';
+                    showMessage(`Error converting ${file.name}: ${error.message}`, 'error');
+                }
+
+                // Update progress
+                const progress = Math.round(((i + 1) / selectedFiles.length) * 100);
+                progressBar.style.width = progress + '%';
+                progressText.textContent = `${progress}% complete (${i + 1}/${selectedFiles.length})`;
+
+                renderFileCards();
+            }
+
+            // Completion
+            convertButton.disabled = false;
+            convertButton.innerHTML = '🔄 Convert Images';
+
+            const successfulConversions = convertedFiles.length;
+            if (successfulConversions > 0) {
+                document.getElementById('download-button').style.display = 'inline-flex';
+                showMessage(`Successfully converted ${successfulConversions} image(s)!`, 'success');
+            }
+
+            setTimeout(() => {
+                progressSection.style.display = 'none';
+            }, 1000);
+        }
+
+        function getConversionSettings() {
+            return {
+                format: document.getElementById('output-format').value
+            };
+        }
+
+        async function upload(file, settings) {
+            const formData = new FormData();
+            formData.append('image', file.file);
+            formData.append('id', file.id);
+
+            try {
+                const response = await fetch('/image/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    throw new Error(errorData.message || `HTTP error! status: ${response.status}`);
+                }
+                return true
+            } catch (error) {
+                throw new Error(`Failed to upload ${file.name}: ${error.message}`);
+            }
+        }
+
+        async function convert(file, settings) {
+            const formData = new FormData();
+            formData.append('id', file.id);
+            formData.append('to_format', settings.format);
+
+            try {
+                const response = await fetch('/image/convert', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    throw new Error(errorData.message || `HTTP error! status: ${response.status}`);
+                }
+
+                const result = await response.json();
+
+                return {
+                    id: file.id,
+                    originalName: file.name,
+                    convertedName: result.new_filename,
+                    url: "/image/download?id="+result.new_filename
+                };
+            } catch (error) {
+                throw new Error(`Failed to upload ${file.name}: ${error.message}`);
+            }
+        }
+
+        function downloadAllFiles() {
+            if (convertedFiles.length === 0) return;
+
+            // Download each converted file
+            convertedFiles.forEach((file, index) => {
+                setTimeout(() => {
+                    const link = document.createElement('a');
+                    link.href = file.url;
+                    link.download = file.convertedName;
+                    link.target = '_blank';
+                    document.body.appendChild(link);
+                    link.click();
+                    document.body.removeChild(link);
+                }, index * 100);
+            });
+        }
+
+        function getStatusText(status) {
+            switch (status) {
+                case 'ready': return 'Ready';
+                case 'uploading': return 'Uploading...';
+                case 'converting': return 'Converting...';
+                case 'completed': return 'Converted';
+                case 'error': return 'Error';
+                default: return 'Unknown';
+            }
+        }
+
+        function formatFileSize(bytes) {
+            if (bytes === 0) return '0 Bytes';
+            const k = 1024;
+            const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(k));
+            return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+        }
+    </script>
+</body>
+
+</html>

image/main.py

@@ -0,0 +1,15 @@
+from process_exception import ProcessAlreadyRunning
+from .image_base import ImageBase
+from .remove_metadata import RemoveMetadata
+
+def remove_metadata():
+	with RemoveMetadata() as processor:
+		processor.remove_metadata("test.png")
+
+def is_process_running():
+	try:
+		ImageBase()
+	except ProcessAlreadyRunning as e:
+		return e.data
+
+	return None

image/process.json

@@ -0,0 +1,4 @@
+{
+    "start_time": "2025-06-29T13:24:50.598935",
+    "feature": "remove_metadata"
+}

image/remove_background.py

@@ -0,0 +1,59 @@
+"""
+Background Remover Module
+
+This module provides a high-quality, class-based background remover using rembg.
+"""
+
+from rembg import remove
+from pathlib import Path
+from custom_logger import logger_config
+
+
+class RemoveBackground:
+    """
+    High-quality background remover using the rembg library.
+    
+    This class provides background removal functionality for supported image formats,
+    with proper validation, logging, and output management.
+    """
+    
+    def __init__(self):
+        self.removal_history = []
+
+    def _get_output_path(self, input_path: Path, output_path: str = None) -> Path:
+        if output_path:
+            return Path(output_path)
+        return input_path.with_name(input_path.stem + "_nobg.png")
+
+    def remove_background(self, input_file_name: str, output_path: str = None, process_id: str = None) -> str:
+        try:
+            # Validate inputs
+            self.input_file_name = input_file_name
+            self.input_file_path = f'{self.input_dir}/{self.input_file_name}'
+            self._validate_input_file()
+            output_file = self._get_output_path(self.input_file_path, output_path)
+
+            logger_config.info(f"🧼 Removing background from: {self.input_file_path}")
+
+            with open(self.input_file_path, 'rb') as infile:
+                input_image = infile.read()
+
+            # Perform background removal
+            output_image = remove(input_image)
+
+            with open(output_file, 'wb') as outfile:
+                outfile.write(output_image)
+
+            logger_config.info(f"✅ Background removed successfully: {output_file}")
+
+            self.removal_history.append({
+                "input": self.input_file_path,
+                "output": str(output_file),
+                "success": True
+            })
+
+            return str(output_file)
+
+        except Exception as e:
+            logger_config.error(f"❌ Background removal failed: {str(e)}")
+            return None

image/remove_metadata.py

@@ -0,0 +1,340 @@
+"""
+Image Metadata Remover Module
+
+This module provides a class-based metadata remover that strips all metadata
+from images while preserving original quality, format, and aspect ratio.
+"""
+
+from .image_base import ImageBase
+import os
+from custom_logger import logger_config
+from PIL import Image
+from PIL.ExifTags import TAGS
+from typing import Dict, List
+
+class RemoveMetadata(ImageBase):
+	"""
+	High-quality image metadata remover that preserves original quality and aspect ratio.
+	
+	This class handles removal of EXIF, IPTC, XMP and other metadata while maintaining
+	the highest possible image quality and exact dimensional preservation.
+	"""
+	def __init__(self):
+		super().__init__("remove_metadata")
+		self.output_suffix = "no_metadata"
+	
+	def _detect_metadata(self, image: Image.Image) -> Dict[str, bool]:
+		"""
+		Detect various types of metadata in the image.
+		
+		Args:
+			image: PIL Image object
+			
+		Returns:
+			Dictionary indicating which metadata types are present
+		"""
+		metadata_found = {
+			'exif': False,
+			'icc_profile': False,
+			'xmp': False,
+			'iptc': False,
+			'other_info': False
+		}
+		
+		# Check for EXIF data
+		if hasattr(image, '_getexif') and image._getexif():
+			metadata_found['exif'] = True
+		
+		# Check image info for various metadata
+		if hasattr(image, 'info') and image.info:
+			if 'icc_profile' in image.info:
+				metadata_found['icc_profile'] = True
+			if 'xmp' in image.info:
+				metadata_found['xmp'] = True
+			if 'iptc' in image.info:
+				metadata_found['iptc'] = True
+			
+			# Check for other metadata
+			metadata_keys = ['dpi', 'description', 'software', 'datetime', 'artist', 'copyright']
+			if any(key in image.info for key in metadata_keys):
+				metadata_found['other_info'] = True
+		
+		return metadata_found
+	
+	def _get_quality_settings_for_format(self, format_name: str, original_mode: str) -> Dict:
+		"""
+		Get optimal save settings for maximum quality preservation per format.
+		
+		Args:
+			format_name: PIL format name
+			original_mode: Original image color mode
+			
+		Returns:
+			Dictionary of save parameters
+		"""
+		settings = {}
+		
+		if format_name == 'JPEG':
+			settings = {
+				'quality': 100,		 # Maximum quality
+				'optimize': False,	  # Don't optimize to preserve quality
+				'progressive': False,   # Standard baseline JPEG
+				'subsampling': 0,	   # No chroma subsampling
+				'exif': b''			# Explicitly remove EXIF
+			}
+			
+		elif format_name == 'PNG':
+			settings = {
+				'optimize': False,	  # Don't optimize to preserve quality
+				'compress_level': 1	 # Minimal compression
+			}
+			
+		elif format_name == 'WEBP':
+			settings = {
+				'lossless': True,	   # Lossless compression
+				'quality': 100,		 # Maximum quality
+				'method': 6			 # Best compression method
+			}
+			
+		elif format_name == 'TIFF':
+			settings = {
+				'compression': None	 # No compression
+			}
+			
+		elif format_name in ['BMP', 'GIF']:
+			settings = {}  # These formats have limited options
+			
+		return settings
+	
+	def _clean_png_with_transparency(self, image: Image.Image, output_path: str) -> bool:
+		"""
+		Clean PNG image while preserving transparency and quality.
+		
+		Args:
+			image: PIL Image object
+			output_path: Path for output file
+			
+		Returns:
+			True if successful
+		"""
+		try:
+			original_mode = image.mode
+			
+			# Create new clean image preserving transparency
+			if original_mode == 'P':
+				# Palette mode - preserve palette
+				clean_img = Image.new(original_mode, image.size)
+				if image.getpalette():
+					clean_img.putpalette(image.getpalette())
+				clean_img.paste(image, (0, 0))
+			else:
+				# RGBA or LA mode
+				clean_img = Image.new(original_mode, image.size, (0, 0, 0, 0))
+				clean_img.paste(image, (0, 0))
+			
+			# Save with quality preservation
+			save_settings = self._get_quality_settings_for_format('PNG', original_mode)
+			clean_img.save(output_path, format='PNG', **save_settings)
+			
+			return True
+			
+		except Exception as e:
+			raise Exception(f"PNG transparency cleaning failed: {e}")
+	
+	def _clean_jpeg_image(self, image: Image.Image, output_path: str) -> bool:
+		"""
+		Clean JPEG image while preserving maximum quality.
+		
+		Args:
+			image: PIL Image object
+			output_path: Path for output file
+			
+		Returns:
+			True if successful
+		"""
+		try:
+			# Convert to RGB if necessary
+			if image.mode != 'RGB':
+				clean_img = image.convert('RGB')
+			else:
+				clean_img = image.copy()
+			
+			# Save with maximum quality and no metadata
+			save_settings = self._get_quality_settings_for_format('JPEG', image.mode)
+			clean_img.save(output_path, format='JPEG', **save_settings)
+			
+			return True
+			
+		except Exception as e:
+			raise Exception(f"JPEG cleaning failed: {e}")
+	
+	def _clean_other_format(self, image: Image.Image, output_path: str, original_format: str) -> bool:
+		"""
+		Clean other image formats while preserving quality.
+		
+		Args:
+			image: PIL Image object
+			output_path: Path for output file
+			original_format: Original image format
+			
+		Returns:
+			True if successful
+		"""
+		try:
+			# Create new image without metadata
+			clean_img = Image.new(image.mode, image.size)
+			
+			# Handle palette images
+			if image.mode == 'P' and image.getpalette():
+				clean_img.putpalette(image.getpalette())
+			
+			# Paste original image data
+			clean_img.paste(image, (0, 0))
+			
+			# Save with format-specific quality settings
+			save_settings = self._get_quality_settings_for_format(original_format, image.mode)
+			clean_img.save(output_path, format=original_format, **save_settings)
+			
+			return True
+			
+		except Exception as e:
+			raise Exception(f"{original_format} cleaning failed: {e}")
+	
+	def _verify_metadata_removal(self) -> bool:
+		"""
+		Verify that metadata has been successfully removed from the cleaned image.
+		Returns:
+			True if metadata was successfully removed
+		"""
+		try:
+			with Image.open(self.input_file_path) as img:
+				metadata_found = self._detect_metadata(img)
+				
+				# Check if any metadata is still present
+				has_metadata = any(metadata_found.values())
+				
+				if has_metadata:
+					present_types = [k for k, v in metadata_found.items() if v]
+					logger_config.warning(f"Warning: Some metadata still present: {present_types}")
+					return False
+				else:
+					logger_config.success("No metadata found in cleaned image")
+					return True
+					
+		except Exception as e:
+			raise Exception(f"Verification failed: {e}")
+	
+	def _verify_image_quality(self, original_path: str, cleaned_path: str) -> bool:
+		"""
+		Verify that image quality and dimensions are preserved.
+		
+		Args:
+			original_path: Path to original image
+			cleaned_path: Path to cleaned image
+			
+		Returns:
+			True if quality is preserved
+		"""
+		try:
+			with Image.open(original_path) as original, Image.open(cleaned_path) as cleaned:
+				# Check dimensions
+				if original.size != cleaned.size:
+					raise Exception(f"Dimension mismatch! Original: {original.size}, Cleaned: {cleaned.size}")
+				
+				# Check if file exists and has reasonable size
+				if not os.path.exists(cleaned_path):
+					return False
+				
+				cleaned_size = os.path.getsize(cleaned_path)
+				if cleaned_size == 0:
+					raise Exception("Cleaned file is empty")
+				
+				logger_config.success(f"Quality preserved - Size: {cleaned.size}, File size: {cleaned_size:,} bytes")
+				return True
+				
+		except Exception as e:
+			raise Exception(f"Quality verification failed: {e}")
+	
+	def remove_metadata(self, input_file_name: str) -> str:
+		"""
+		Remove all metadata from an image while preserving quality and aspect ratio.
+		
+		Args:
+			input_file_name: Input image name
+			custom_output_path: Optional custom output path (overrides default naming)
+			
+		Returns:
+			Path to cleaned image
+			
+		Raises:
+			FileNotFoundError: If input file doesn't exist
+			ValueError: If file format is not supported
+			Exception: If metadata removal fails
+		"""
+		try:
+			self.input_file_name = input_file_name
+			self.input_file_path = f'{self.input_dir}/{self.input_file_name}'
+			# Validate input
+			input_file = self._validate_input_file()
+			
+			# Generate output path
+			output_path = self._generate_output_path()
+			
+			logger_config.info(f"Processing: {input_file.name}")
+			
+			# Open and analyze image
+			with Image.open(str(input_file)) as image:
+				original_size = image.size
+				original_format = image.format
+				original_mode = image.mode
+				
+				# Detect metadata
+				metadata_found = self._detect_metadata(image)
+				metadata_types = [k for k, v in metadata_found.items() if v]
+				
+				if metadata_types:
+					logger_config.info(f"Found metadata types: {metadata_types}")
+				else:
+					logger_config.info("No metadata detected")
+				
+				# Choose appropriate cleaning method based on format and characteristics
+				success = False
+				
+				if original_format == 'PNG' and original_mode in ('RGBA', 'LA', 'P'):
+					success = self._clean_png_with_transparency(image, output_path)
+					
+				elif original_format == 'JPEG' or output_path.lower().endswith(('.jpg', '.jpeg')):
+					success = self._clean_jpeg_image(image, output_path)
+					
+				else:
+					success = self._clean_other_format(image, output_path, original_format)
+				
+				if not success:
+					raise Exception("Metadata cleaning failed")
+			
+			# Verify results
+			self._verify_image_quality(str(input_file), output_path)
+			
+			self._verify_metadata_removal(output_path)
+			
+			logger_config.success(f"Cleaned image saved: {output_path}")
+			return output_path
+			
+		except Exception as e:
+			logger_config.error(f"Failed to clean image: {str(e)}")
+			return None
+
+	def set_output_suffix(self, suffix: str) -> None:
+		"""
+		Change the output filename suffix for cleaned images.
+		
+		Args:
+			suffix: New suffix to use (e.g., "_clean", "_no_exif")
+		"""
+		self.output_suffix = suffix
+		logger_config.info(f"Output suffix changed to: {suffix}")
+
+# Example usage
+if __name__ == "__main__":
+	cleaner = RemoveMetadata()
+	cleaned_file = cleaner.remove_metadata("image/input/test.png")

index.html

@@ -0,0 +1,607 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Tools Collection</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }
+
+        .header {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 40px 30px;
+            text-align: center;
+        }
+
+        .header h1 {
+            font-size: 3rem;
+            margin-bottom: 15px;
+            font-weight: 300;
+        }
+
+        .header p {
+            font-size: 1.2rem;
+            opacity: 0.9;
+            margin-bottom: 30px;
+        }
+
+        .search-container {
+            max-width: 500px;
+            margin: 0 auto;
+            position: relative;
+            margin-bottom: 20px;
+        }
+
+        .search-box {
+            width: 100%;
+            padding: 15px 50px 15px 20px;
+            border: none;
+            border-radius: 50px;
+            font-size: 1.1rem;
+            background: rgba(255, 255, 255, 0.9);
+            backdrop-filter: blur(10px);
+            transition: all 0.3s ease;
+        }
+
+        .search-box:focus {
+            outline: none;
+            background: white;
+            box-shadow: 0 5px 20px rgba(0,0,0,0.1);
+        }
+
+        .search-icon {
+            position: absolute;
+            right: 20px;
+            top: 50%;
+            transform: translateY(-50%);
+            font-size: 1.2rem;
+            color: #667eea;
+        }
+
+        .filter-container {
+            max-width: 300px;
+            margin: 0 auto;
+        }
+
+        .category-dropdown {
+            width: 100%;
+            padding: 12px 20px;
+            border: none;
+            border-radius: 50px;
+            font-size: 1rem;
+            background: rgba(255, 255, 255, 0.9);
+            backdrop-filter: blur(10px);
+            color: #495057;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        .category-dropdown:focus {
+            outline: none;
+            background: white;
+            box-shadow: 0 5px 20px rgba(0,0,0,0.1);
+        }
+
+        .content {
+            padding: 40px;
+        }
+
+        .features-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 25px;
+            margin-top: 30px;
+        }
+
+        .feature-card {
+            background: white;
+            border-radius: 15px;
+            padding: 30px;
+            border: 1px solid #e9ecef;
+            transition: all 0.3s ease;
+            cursor: pointer;
+            text-decoration: none;
+            color: inherit;
+            display: block;
+            position: relative;
+            overflow: hidden;
+        }
+
+        .feature-card::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            height: 4px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            transform: scaleX(0);
+            transition: transform 0.3s ease;
+        }
+
+        .feature-card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 15px 40px rgba(0,0,0,0.1);
+        }
+
+        .feature-card:hover::before {
+            transform: scaleX(1);
+        }
+
+        .feature-card.coming-soon {
+            opacity: 0.6;
+            cursor: not-allowed;
+        }
+
+        .feature-card.coming-soon:hover {
+            transform: none;
+            box-shadow: none;
+        }
+
+        .feature-header {
+            display: flex;
+            align-items: center;
+            gap: 15px;
+            margin-bottom: 15px;
+        }
+
+        .feature-icon {
+            font-size: 2.5rem;
+            width: 60px;
+            height: 60px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background: linear-gradient(135deg, #667eea15, #764ba215);
+            border-radius: 12px;
+        }
+
+        .feature-card h3 {
+            color: #495057;
+            font-size: 1.4rem;
+            font-weight: 600;
+        }
+
+        .feature-card p {
+            color: #6c757d;
+            margin-bottom: 20px;
+            line-height: 1.6;
+        }
+
+        .feature-status {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            margin-bottom: 15px;
+        }
+
+        .status-indicator {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            background: #28a745;
+        }
+
+        .status-indicator.busy {
+            background: #ffc107;
+            animation: pulse 2s infinite;
+        }
+
+        .status-indicator.coming-soon {
+            background: #6c757d;
+        }
+
+        @keyframes pulse {
+            0% { transform: scale(1); opacity: 1; }
+            50% { transform: scale(1.2); opacity: 0.7; }
+            100% { transform: scale(1); opacity: 1; }
+        }
+
+        .feature-tags {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 8px;
+            margin-top: 15px;
+        }
+
+        .tag {
+            background: #f8f9fa;
+            color: #495057;
+            padding: 4px 12px;
+            border-radius: 20px;
+            font-size: 0.8rem;
+            border: 1px solid #e9ecef;
+        }
+
+        .coming-soon-badge {
+            position: absolute;
+            top: 15px;
+            right: 15px;
+            background: #6c757d;
+            color: white;
+            padding: 4px 12px;
+            border-radius: 20px;
+            font-size: 0.8rem;
+            font-weight: 500;
+        }
+
+        .stat-item h4 {
+            color: #667eea;
+            font-size: 1.5rem;
+            margin-bottom: 5px;
+        }
+
+        .stat-item p {
+            color: #6c757d;
+            font-size: 0.9rem;
+        }
+
+        .no-results {
+            text-align: center;
+            padding: 60px 20px;
+            color: #6c757d;
+        }
+
+        .no-results .icon {
+            font-size: 4rem;
+            margin-bottom: 20px;
+            opacity: 0.5;
+        }
+
+        .feature-path {
+            color: #667eea;
+            font-size: 0.9rem;
+            font-weight: 500;
+            margin-bottom: 5px;
+        }
+
+        @media (max-width: 768px) {
+            .header h1 {
+                font-size: 2rem;
+            }
+            
+            .header p {
+                font-size: 1rem;
+            }
+            
+            .content {
+                padding: 20px;
+            }
+            
+            .features-grid {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🛠️ Tools Collection</h1>
+            <p>Simple, fast, and reliable utility tools for your daily needs</p>
+            
+            <div class="search-container">
+                <input type="text" id="search-box" class="search-box" placeholder="Search tools... (e.g., image, pdf, convert)">
+                <span class="search-icon">🔍</span>
+            </div>
+
+            <div class="filter-container">
+                <select id="category-dropdown" class="category-dropdown">
+                    <option value="">All Categories</option>
+                </select>
+            </div>
+        </div>
+
+        <div class="content">
+            <div class="features-grid" id="features-grid">
+                <!-- Features will be populated by JavaScript -->
+            </div>
+            
+            <div class="no-results" id="no-results" style="display: none;">
+                <div class="icon">🔍</div>
+                <h3>No tools found</h3>
+                <p>Try searching with different keywords like "image", "pdf", or "convert"</p>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let allFeatures = {};
+        let expandedFeatures = [];
+        let currentCategory = '';
+        let currentSearch = '';
+        
+        // Load features on page load
+        document.addEventListener('DOMContentLoaded', async () => {
+            await loadFeatures();
+            setupSearch();
+            setupCategoryFilter();
+            updateFeatureStatuses();
+            
+            // Update statuses every 5 seconds
+            setInterval(updateFeatureStatuses, 5000);
+        });
+        
+        async function loadFeatures() {
+            try {
+                const response = await fetch('/api/features');
+                if (response.ok) {
+                    const data = await response.json();
+                    allFeatures = data.features;
+                    expandFeatures();
+                    populateCategories();
+                    displayFeatures(expandedFeatures);
+                }
+            } catch (error) {
+                console.error('Error loading features:', error);
+                // Fallback to mock data for demo
+                loadMockData();
+            }
+        }
+
+        function loadMockData() {
+            allFeatures = {
+                "image": {
+                    "name": "Image Tools",
+                    "description": "HEIC to PNG/JPG conversion and metadata removal",
+                    "icon": "🖼️",
+                    "features": ["convert", "remove_metadata"],
+                    "folder": "image",
+                    "tags": ["image", "heic", "png", "jpg", "convert", "metadata"]
+                },
+                "pdf": {
+                    "name": "PDF Tools",
+                    "description": "Convert images to PDF, merge PDFs, and more",
+                    "icon": "📄",
+                    "features": ["images_to_pdf"],
+                    "folder": "pdf",
+                    "tags": ["pdf", "merge", "convert", "images", "document"],
+                    "coming_soon": true
+                },
+                "audio": {
+                    "name": "Audio Tools",
+                    "description": "Convert audio formats and compress audio files",
+                    "icon": "🎵",
+                    "features": ["convert_audio", "compress_audio"],
+                    "folder": "audio",
+                    "tags": ["audio", "music", "convert", "compress", "mp3", "wav"],
+                    "coming_soon": true
+                },
+                "video": {
+                    "name": "Video Tools",
+                    "description": "Basic video editing and format conversion",
+                    "icon": "🎬",
+                    "features": ["convert_video", "compress_video"],
+                    "folder": "video",
+                    "tags": ["video", "convert", "compress", "mp4", "avi", "editing"],
+                    "coming_soon": true
+                }
+            };
+            expandFeatures();
+            populateCategories();
+            displayFeatures(expandedFeatures);
+        }
+        
+        function expandFeatures() {
+            expandedFeatures = [];
+            
+            Object.entries(allFeatures).forEach(([categoryKey, categoryData]) => {
+                // Add the main category
+                // expandedFeatures.push({
+                //     id: categoryKey,
+                //     path: categoryKey,
+                //     name: categoryData.name,
+                //     description: categoryData.description,
+                //     icon: categoryData.icon,
+                //     tags: categoryData.tags || [],
+                //     coming_soon: categoryData.coming_soon || false,
+                //     category: categoryKey,
+                //     type: 'category'
+                // });
+                
+                // Add individual features
+                if (categoryData.features && categoryData.features.length > 0) {
+                    categoryData.features.forEach(feature => {
+                        expandedFeatures.push({
+                            id: `${categoryKey}-${feature}`,
+                            path: `${categoryKey}/${feature}`,
+                            name: `${categoryData.name} - ${formatFeatureName(feature)}`,
+                            description: getFeatureDescription(categoryKey, feature),
+                            icon: categoryData.icon,
+                            tags: [...(categoryData.tags || []), feature],
+                            coming_soon: categoryData.coming_soon || false,
+                            category: categoryKey,
+                            type: 'feature'
+                        });
+                    });
+                }
+            });
+        }
+        
+        function formatFeatureName(feature) {
+            return feature.split('_')
+                .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+                .join(' ');
+        }
+        
+        function getFeatureDescription(category, feature) {
+            const descriptions = {
+                'image': {
+                    'convert': 'Convert HEIC images to PNG/JPG format',
+                    'remove_metadata': 'Remove metadata from image files'
+                },
+                'pdf': {
+                    'images_to_pdf': 'Convert multiple images into a single PDF'
+                },
+                'audio': {
+                    'convert_audio': 'Convert between different audio formats',
+                    'compress_audio': 'Reduce audio file size while maintaining quality'
+                },
+                'video': {
+                    'convert_video': 'Convert between different video formats',
+                    'compress_video': 'Reduce video file size while maintaining quality'
+                }
+            };
+            
+            return descriptions[category]?.[feature] || `${formatFeatureName(feature)} functionality`;
+        }
+        
+        function populateCategories() {
+            const dropdown = document.getElementById('category-dropdown');
+            const categories = Object.keys(allFeatures);
+            
+            categories.forEach(category => {
+                const option = document.createElement('option');
+                option.value = category;
+                option.textContent = allFeatures[category].name;
+                dropdown.appendChild(option);
+            });
+        }
+        
+        function displayFeatures(features) {
+            const grid = document.getElementById('features-grid');
+            const noResults = document.getElementById('no-results');
+            
+            if (features.length === 0) {
+                grid.style.display = 'none';
+                noResults.style.display = 'block';
+                return;
+            }
+            
+            grid.style.display = 'grid';
+            noResults.style.display = 'none';
+            
+            grid.innerHTML = features.map((feature) => {
+                const isComingSoon = feature.coming_soon || false;
+                const href = isComingSoon ? '#' : `/${feature.path}`;
+                
+                return `
+                    <a href="${href}" class="feature-card ${isComingSoon ? 'coming-soon' : ''}" 
+                       ${isComingSoon ? 'onclick="return false;"' : ''}>
+                        ${isComingSoon ? '<div class="coming-soon-badge">Coming Soon</div>' : ''}
+                        
+                        <div class="feature-path">${feature.path}</div>
+                        
+                        <div class="feature-header">
+                            <div class="feature-icon">${feature.icon}</div>
+                            <h3>${feature.name}</h3>
+                        </div>
+                        
+                        <p>${feature.description}</p>
+                        
+                        <div class="feature-status">
+                            <div class="status-indicator ${isComingSoon ? 'coming-soon' : ''}" 
+                                 id="${feature.id}-status"></div>
+                            <span id="${feature.id}-status-text">${isComingSoon ? 'Coming Soon' : 'Ready'}</span>
+                        </div>
+                        
+                        <div class="feature-tags">
+                            ${feature.tags ? feature.tags.map(tag => `<span class="tag">${tag}</span>`).join('') : ''}
+                        </div>
+                    </a>
+                `;
+            }).join('');
+        }
+        
+        function setupSearch() {
+            const searchBox = document.getElementById('search-box');
+            let debounceTimer;
+            
+            searchBox.addEventListener('input', (e) => {
+                clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(() => {
+                    currentSearch = e.target.value.toLowerCase();
+                    filterFeatures();
+                }, 300);
+            });
+        }
+        
+        function setupCategoryFilter() {
+            const dropdown = document.getElementById('category-dropdown');
+            
+            dropdown.addEventListener('change', (e) => {
+                currentCategory = e.target.value;
+                filterFeatures();
+            });
+        }
+        
+        function filterFeatures() {
+            let filteredFeatures = expandedFeatures;
+            
+            // Filter by category
+            if (currentCategory) {
+                filteredFeatures = filteredFeatures.filter(feature => 
+                    feature.category === currentCategory
+                );
+                }
+            
+            // Filter by search term
+            if (currentSearch) {
+                filteredFeatures = filteredFeatures.filter(feature => 
+                    feature.name.toLowerCase().includes(currentSearch) ||
+                    feature.description.toLowerCase().includes(currentSearch) ||
+                    feature.path.toLowerCase().includes(currentSearch) ||
+                    feature.tags.some(tag => tag.toLowerCase().includes(currentSearch))
+                );
+            }
+            
+            displayFeatures(filteredFeatures);
+        }
+        
+        async function updateFeatureStatuses() {
+            for (const feature of expandedFeatures) {
+                if (feature.coming_soon) continue;
+                
+                try {
+                    const response = await fetch(`/api/status`);
+                    if (response.ok) {
+                        const status = await response.json();
+                        updateFeatureStatus(feature.id, status);
+                    }
+                } catch (error) {
+                    console.error(`Error checking status for ${feature.id}:`, error);
+                }
+            }
+        }
+        
+        function updateFeatureStatus(featureId, status) {
+            const indicator = document.getElementById(`${featureId}-status`);
+            const text = document.getElementById(`${featureId}-status-text`);
+            
+            if (!indicator || !text) return;
+            
+            // For demo purposes, randomly show some as busy
+            const isBusy = Math.random() < 0.1;
+            
+            if (isBusy) {
+                indicator.classList.add('busy');
+                text.textContent = 'Processing...';
+            } else {
+                indicator.classList.remove('busy');
+                text.textContent = 'Ready';
+            }
+        }
+    </script>
+</body>
+</html>

main.py

@@ -0,0 +1,231 @@
+from fastapi import FastAPI, Request, File, UploadFile, HTTPException, Form, Query
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+from custom_logger import logger_config
+from image.main import is_process_running as is_image_process_running
+from image.image_base import ImageBase
+from pydantic import BaseModel
+from image.converter import Converter
+import mimetypes
+
+app = FastAPI(title="Tools Collection", description="Collection of utility tools")
+
+# Create necessary directories
+# os.makedirs("static", exist_ok=True)
+
+# Mount static files
+# app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Templates
+template_dirs = [".", "./image"]
+env = Environment(
+    loader=FileSystemLoader(template_dirs),
+    autoescape=select_autoescape(['html', 'xml'])
+)
+
+# Available features
+FEATURES = {
+    "image": {
+        "name": "Image Tools",
+        "description": "HEIC to PNG/JPG conversion and metadata removal",
+        "icon": "🖼️",
+        "features": ["convert", "remove_metadata"],
+        "folder": "image",
+        "tags": ["image", "heic", "png", "jpg", "convert", "metadata"],
+        "is_process_running": is_image_process_running
+    },
+    "pdf": {
+        "name": "PDF Tools", 
+        "description": "Convert images to PDF, merge PDFs, and more",
+        "icon": "📄",
+        "features": ["images_to_pdf"],
+        "folder": "pdf",
+        "tags": ["pdf", "merge", "convert", "images", "document"],
+        "coming_soon": True,
+        "is_process_running": is_image_process_running
+    },
+    "audio": {
+        "name": "Audio Tools",
+        "description": "Convert audio formats and compress audio files",
+        "icon": "🎵",
+        "features": ["convert_audio", "compress_audio"],
+        "folder": "audio", 
+        "tags": ["audio", "music", "convert", "compress", "mp3", "wav"],
+        "coming_soon": True,
+        "is_process_running": is_image_process_running
+    },
+    "video": {
+        "name": "Video Tools",
+        "description": "Basic video editing and format conversion",
+        "icon": "🎬",
+        "features": ["convert_video", "compress_video"],
+        "folder": "video",
+        "tags": ["video", "convert", "compress", "mp4", "avi", "editing"],
+        "coming_soon": True,
+        "is_process_running": is_image_process_running
+    }
+}
+
+# Routes
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    template = env.get_template("index.html")  # From tool/
+    html_content = template.render(request=request)
+    return HTMLResponse(content=html_content)
+
+@app.get("/image/convert", response_class=HTMLResponse)
+async def image_tools(request: Request):
+    template = env.get_template("image/index.html")  # From tool/image/
+    html_content = template.render(request=request)
+    return HTMLResponse(content=html_content)
+
+@app.post("/image/upload")
+async def upload_image(
+    id: str = Form(...),
+    image: UploadFile = File(...)
+):
+    try:
+        image_base = ImageBase()
+        image_base.upload(id, image)
+        
+        # Return success response
+        return JSONResponse({
+            "success": True,
+            "message": "Image uploaded successfully"
+        })
+    
+    except ValueError as ve:
+        logger_config.error(f"Validation error: {str(ve)}")
+        raise HTTPException(
+            status_code=400,
+            detail=str(ve)
+        )
+    except Exception as e:
+        logger_config.error(f"Unexpected error during upload: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal server error: {str(e)}"
+        )
+
+@app.post("/image/convert")
+async def convert_image(
+    id: str = Form(...),
+    to_format: str = Form(...)
+):
+    try:
+        converter = Converter()
+        output_path = converter.convert_image(id, to_format)
+        
+        # Return success response
+        return JSONResponse({
+            "success": True,
+            "message": "Image uploaded successfully",
+            "new_filename": output_path.split("/")[-1]
+        })
+    
+    except ValueError as ve:
+        logger_config.error(f"Validation error: {str(ve)}")
+        raise HTTPException(
+            status_code=400,
+            detail=str(ve)
+        )
+    except Exception as e:
+        logger_config.error(f"Unexpected error during upload: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal server error: {str(e)}"
+        )
+
+@app.get("/image/download")
+async def download_converted_image(
+    id: str = Query(...)
+):
+    try:
+        image_base = ImageBase()
+        file_path = image_base.download_url(id)
+        
+        mime_type, _ = mimetypes.guess_type(file_path)
+
+        return FileResponse(file_path, media_type=mime_type, filename=id)
+
+    except ValueError as ve:
+        logger_config.error(f"Validation error: {str(ve)}")
+        raise HTTPException(
+            status_code=400,
+            detail=str(ve)
+        )
+    except Exception as e:
+        logger_config.error(f"Unexpected error during upload: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal server error: {str(e)}"
+        )
+
+class DeleteRequest(BaseModel):
+    ids: list[str]
+
+@app.post("/image/delete")
+async def delete_images(request: DeleteRequest):
+    try:
+        image_base = ImageBase()
+        image_base.delete(request.ids)
+        
+        # Return success response
+        return JSONResponse({
+            "success": True,
+            "message": "Image deleted successfully"
+        })
+    
+    except ValueError as ve:
+        logger_config.error(f"Validation error: {str(ve)}")
+        raise HTTPException(
+            status_code=400,
+            detail=str(ve)
+        )
+    except Exception as e:
+        logger_config.error(f"Unexpected error during upload: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal server error: {str(e)}"
+        )
+
+@app.get("/api/features")
+async def get_features():
+    """Get available features"""
+    return {"features": FEATURES}
+
+@app.get("/api/search")
+async def search_features(q: str = ""):
+    """Search features by name, description, or tags"""
+    if not q:
+        return {"features": FEATURES}
+    
+    q = q.lower()
+    filtered_features = {}
+    
+    for key, feature in FEATURES.items():
+        # Search in name, description, and tags
+        search_text = f"{feature['name']} {feature['description']} {' '.join(feature.get('tags', []))}".lower()
+        if q in search_text:
+            filtered_features[key] = feature
+    
+    return {"features": filtered_features}
+
+@app.get("/api/status")
+async def get_feature_status():
+    """Get feature status"""
+    features_status = {}
+    for key in FEATURES.keys():
+        process_data = FEATURES[key]["is_process_running"]()
+        features_status[key] = {
+            "feature_name": process_data["feature"] if process_data else None,
+            "is_busy": process_data is not None,
+            "process_id": process_data["process_id"] if process_data else None
+        }
+    
+    return features_status
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

main_base.py

@@ -0,0 +1,59 @@
+import shutil
+from custom_logger import logger_config
+import os
+from pathlib import Path
+
+class MainBase:
+	def __init__(self):
+		self.max_file_size = 10 * 1024 * 1024
+
+	def upload_validate(self, image):
+		# Reset file pointer to beginning before reading
+		image.file.seek(0)
+		contents = image.file.read()
+		# Reset file pointer again for later use
+		image.file.seek(0)
+		
+		if len(contents) > self.max_file_size:
+			raise ValueError(f"{image.filename} is too large. Max size: {self.max_file_size // (1024*1024)}MB.")
+
+	def upload(self, id, image):
+		self.upload_validate(image)
+		# Create full file path with filename
+		file_path = os.path.join(self.input_dir, id)
+		
+		with open(file_path, "wb") as buffer:
+			shutil.copyfileobj(image.file, buffer)
+
+		logger_config.success(f"{image.filename} uploaded successfully to {file_path}")
+
+	def _generate_output_path(self, output_format=None) -> str:
+		if output_format:
+			new_ext = self.supported_formats.get(output_format, output_format).lower()
+			name_without_ext = os.path.splitext(self.input_file_name)[0]
+			return f"{self.output_dir}/{name_without_ext}.{new_ext}"
+		return f"{self.output_dir}/{self.input_file_name}"
+
+	def download_url(self, file_id):
+		self.delete([file_id], only_input=True)
+
+		file_path = f'{self.output_dir}/{file_id}'
+		if os.path.exists(file_path):
+			return file_path
+		raise ValueError("File not found")
+
+	def delete(self, ids, only_input=False):
+		for file_id in ids:
+			name_without_ext = os.path.splitext(file_id)[0]
+			for filename in os.listdir(self.input_dir):
+				if name_without_ext in filename:
+					file_path = os.path.join(self.input_dir, filename)
+					path_obj = Path(file_path)
+					path_obj.unlink(missing_ok=True)
+
+			if not only_input:
+				for filename in os.listdir(self.output_dir):
+					if name_without_ext in filename:
+						file_path = os.path.join(self.output_dir, filename)
+						path_obj = Path(file_path)
+						path_obj.unlink(missing_ok=True)

process_exception.py

@@ -0,0 +1,4 @@
+class ProcessAlreadyRunning(Exception):
+    def __init__(self, message, data):
+        super().__init__(message)
+        self.data = data

requirements.txt

@@ -0,0 +1,8 @@
+git+https://github.com/jebin2/custom_logger.git
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+pillow==10.1.0
+pillow-heif==0.13.0
+aiofiles==23.2.1
+jinja2==3.1.2