added all the features

.gitignore

@@ -0,0 +1 @@
+.venv

app.py

@@ -0,0 +1,380 @@
+import gradio as gr
+import os
+import shutil
+import PIL
+from PIL import Image
+import py7zr
+import tarfile
+import zipfile
+import ffmpeg
+from pathlib import Path
+import tempfile
+from PIL import ImageDraw
+def generate_thumbnail(input_video, time_position=0):
+    if input_video is None:
+        return None
+    
+    temp_dir = tempfile.mkdtemp()
+    output_path = os.path.join(temp_dir, "thumbnail.jpg")
+    
+    stream = ffmpeg.input(input_video.name, ss=time_position)
+    stream = ffmpeg.output(stream, output_path, vframes=1)
+    ffmpeg.run(stream, overwrite_output=True)
+    
+    return output_path
+
+def extract_audio(input_video, output_format="mp3"):
+    if input_video is None:
+        return None
+    
+    temp_dir = tempfile.mkdtemp()
+    output_path = os.path.join(temp_dir, f"extracted_audio.{output_format}")
+    
+    stream = ffmpeg.input(input_video.name)
+    stream = ffmpeg.output(stream, output_path, acodec='libmp3lame')
+    ffmpeg.run(stream, overwrite_output=True)
+    
+    return output_path
+
+def trim_video(input_video, start_time, end_time):
+    if input_video is None:
+        return None
+    
+    temp_dir = tempfile.mkdtemp()
+    output_path = os.path.join(temp_dir, "trimmed_video.mp4")
+    
+    stream = ffmpeg.input(input_video.name, ss=start_time, t=end_time-start_time)
+    stream = ffmpeg.output(stream, output_path, acodec='copy', vcodec='copy')
+    ffmpeg.run(stream, overwrite_output=True)
+    
+    return output_path
+
+def crop_image(input_image, x1, y1, x2, y2):
+    if input_image is None:
+        return None
+    
+    temp_dir = tempfile.mkdtemp()
+    img = Image.open(input_image.name)
+    cropped = img.crop((x1, y1, x2, y2))
+    
+    output_path = os.path.join(temp_dir, f"cropped_image.{input_image.name.split('.')[-1]}")
+    cropped.save(output_path)
+    
+    return output_path
+
+def add_watermark(input_image, watermark_text, position="bottom-right"):
+    if input_image is None:
+        return None
+    
+    temp_dir = tempfile.mkdtemp()
+    img = Image.open(input_image.name)
+    draw = ImageDraw.Draw(img)
+    
+    # Basic font settings - you can enhance this with custom fonts
+    font_size = int(min(img.width, img.height) * 0.05)
+    text_width = len(watermark_text) * font_size * 0.6
+    text_height = font_size
+    
+    # Position mapping
+    positions = {
+        "top-left": (10, 10),
+        "top-right": (img.width - text_width - 10, 10),
+        "bottom-left": (10, img.height - text_height - 10),
+        "bottom-right": (img.width - text_width - 10, img.height - text_height - 10)
+    }
+    
+    x, y = positions.get(position, positions["bottom-right"])
+    draw.text((x, y), watermark_text, fill=(255, 255, 255, 128))
+    
+    output_path = os.path.join(temp_dir, f"watermarked_image.{input_image.name.split('.')[-1]}")
+    img.save(output_path)
+    
+    return output_path
+
+def convert_image(input_image, output_format, compression_level):
+    if input_image is None:
+        return None
+    
+    temp_dir = tempfile.mkdtemp()
+    output_path = os.path.join(temp_dir, f"converted_image.{output_format.lower()}")
+    
+    img = Image.open(input_image.name)
+    
+    if output_format.lower() == 'jpeg' and img.mode == 'RGBA':
+        background = Image.new('RGB', img.size, (255, 255, 255))
+        background.paste(img, mask=img.split()[3])
+        img = background
+    
+    # Quality ranges from 1 (worst) to 95 (best)
+    quality = max(1, min(95, int(95 - (compression_level * 0.94))))
+    
+    if output_format.lower() in ['jpeg', 'webp']:
+        img.save(output_path, quality=quality, optimize=True)
+    elif output_format.lower() == 'png':
+        img.save(output_path, optimize=True, compression_level=int(compression_level/10))
+    else:
+        img.save(output_path)
+    
+    return output_path
+
+def compress_video(input_video, compression_level, output_format="mp4"):
+    if input_video is None:
+        return None
+        
+    temp_dir = tempfile.mkdtemp()
+    output_path = os.path.join(temp_dir, f"compressed_video.{output_format}")
+    
+    # CRF scale is 0-51 (lower means better quality, higher means more compression)
+    crf = int(51 * (compression_level / 100))
+    
+    stream = ffmpeg.input(input_video.name)
+    stream = ffmpeg.output(stream, output_path,
+                          vcodec='libx265',
+                          crf=crf,
+                          acodec='aac')
+    ffmpeg.run(stream, overwrite_output=True)
+    
+    return output_path
+
+def compress_files(input_files, compression_format, compression_level):
+    if not input_files:
+        return None
+        
+    temp_dir = tempfile.mkdtemp()
+    timestamp = Path(input_files[0].name).stem
+    
+    if compression_format == "zip":
+        output_path = os.path.join(temp_dir, f"compressed_{timestamp}.zip")
+        compression = zipfile.ZIP_DEFLATED
+        compresslevel = int(9 * compression_level / 100)  # 0-9 scale
+        with zipfile.ZipFile(output_path, 'w', compression=compression, compresslevel=compresslevel) as zipf:
+            for file in input_files:
+                zipf.write(file.name, os.path.basename(file.name))
+                
+    if compression_format == "7z":
+        output_path = os.path.join(temp_dir, f"compressed_{timestamp}.7z")
+        # Map compression level to preset filters
+        compression_filters = [
+            {'id': py7zr.FILTER_LZMA2, 'preset': int(9 * compression_level / 100)}
+        ]
+        with py7zr.SevenZipFile(output_path, 'w', filters=compression_filters) as szf:
+            for file in input_files:
+                szf.write(file.name, os.path.basename(file.name))
+                
+    elif compression_format == "tar.gz":
+        output_path = os.path.join(temp_dir, f"compressed_{timestamp}.tar.gz")
+        compresslevel = int(9 * compression_level / 100)  # 0-9 scale
+        with tarfile.open(output_path, "w:gz", compresslevel=compresslevel) as tar:
+            for file in input_files:
+                tar.add(file.name, arcname=os.path.basename(file.name))
+                
+    elif compression_format == "tar.xz":
+        output_path = os.path.join(temp_dir, f"compressed_{timestamp}.tar.xz")
+        preset = int(9 * compression_level / 100)  # 0-9 scale
+        with tarfile.open(output_path, "w:xz", preset=preset) as tar:
+            for file in input_files:
+                tar.add(file.name, arcname=os.path.basename(file.name))
+    
+    return output_path
+
+def resize_image(input_image, width, height, maintain_aspect):
+    if input_image is None:
+        return None
+        
+    temp_dir = tempfile.mkdtemp()
+    img = Image.open(input_image.name)
+    
+    if maintain_aspect:
+        # Calculate new dimensions maintaining aspect ratio
+        aspect_ratio = img.width / img.height
+        if width:
+            height = int(width / aspect_ratio)
+        else:
+            width = int(height * aspect_ratio)
+    
+    # Ensure we have valid dimensions
+    width = width if width else img.width
+    height = height if height else img.height
+    
+    resized_img = img.resize((width, height), Image.Resampling.LANCZOS)
+    output_path = os.path.join(temp_dir, f"resized_image.{input_image.name.split('.')[-1]}")
+    resized_img.save(output_path)
+    
+    return output_path
+
+
+# Create the Gradio interface
+with gr.Blocks(title="Media Toolbox") as app:
+    gr.Markdown("""# Universal Media Toolbox (For all Your Ai Media Needs ✨✨)
+                   #### Note: Higher compression values will significantly reduce file quality and size.
+                   #### Recommended compression levels:
+                   #### - Images: 20-40 for good balance between quality and size
+                   #### - Videos: 30-50 for reasonable quality
+                   #### - Files: 50-70 for general use
+                   #### Only use maximum compression (90-100) when file size is critical and quality loss is acceptable
+                """)
+    
+    with gr.Tab("Image Conversion"):
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.File(label="Upload Image")
+                image_format = gr.Dropdown(
+                    choices=["PNG", "JPEG", "WEBP", "GIF", "BMP"],
+                    value="PNG",
+                    label="Convert to Format"
+                )
+                image_compression = gr.Slider(
+                    minimum=0,
+                    maximum=100,
+                    value=20,
+                    label="Compression Level (0: Highest Quality, 100: Maximum Compression)"
+                )
+                image_convert_btn = gr.Button("Convert Image")
+            with gr.Column():
+                image_output = gr.File(label="Converted Image")
+    
+    with gr.Tab("Image Resize"):
+        with gr.Row():
+            with gr.Column():
+                resize_input = gr.File(label="Upload Image")
+                with gr.Row():
+                    width = gr.Number(label="Width (pixels)", value=800)
+                    height = gr.Number(label="Height (pixels)", value=600)
+                maintain_aspect = gr.Checkbox(label="Maintain Aspect Ratio", value=True)
+                resize_btn = gr.Button("Resize Image")
+            with gr.Column():
+                resize_output = gr.File(label="Resized Image")
+    
+    with gr.Tab("Image Crop"):
+        with gr.Row():
+            with gr.Column():
+                crop_input = gr.File(label="Upload Image")
+                with gr.Row():
+                    x1 = gr.Number(label="Left", value=0)
+                    y1 = gr.Number(label="Top", value=0)
+                    x2 = gr.Number(label="Right", value=100)
+                    y2 = gr.Number(label="Bottom", value=100)
+                crop_btn = gr.Button("Crop Image")
+            with gr.Column():
+                crop_output = gr.File(label="Cropped Image")
+    
+    with gr.Tab("Image Watermark"):
+        with gr.Row():
+            with gr.Column():
+                watermark_input = gr.File(label="Upload Image")
+                watermark_text = gr.Textbox(label="Watermark Text")
+                position = gr.Dropdown(
+                    choices=["top-left", "top-right", "bottom-left", "bottom-right"],
+                    value="bottom-right",
+                    label="Position"
+                )
+                watermark_btn = gr.Button("Add Watermark")
+            with gr.Column():
+                watermark_output = gr.File(label="Watermarked Image")
+    
+    with gr.Tab("Video Compression"):
+        with gr.Row():
+            with gr.Column():
+                video_input = gr.File(label="Upload Video")
+                compression_level = gr.Slider(
+                    minimum=0,
+                    maximum=100,
+                    value=50,
+                    label="Compression Level (0: Highest Quality, 100: Highest Compression)"
+                )
+                video_compress_btn = gr.Button("Compress Video")
+            with gr.Column():
+                video_output = gr.File(label="Compressed Video")
+    
+    with gr.Tab("Video Trim"):
+        with gr.Row():
+            with gr.Column():
+                trim_input = gr.File(label="Upload Video")
+                with gr.Row():
+                    start_time = gr.Number(label="Start Time (seconds)", value=0)
+                    end_time = gr.Number(label="End Time (seconds)", value=10)
+                trim_btn = gr.Button("Trim Video")
+            with gr.Column():
+                trim_output = gr.File(label="Trimmed Video")
+    
+    with gr.Tab("Audio Extraction"):
+        with gr.Row():
+            with gr.Column():
+                audio_input = gr.File(label="Upload Video")
+                audio_format = gr.Dropdown(
+                    choices=["mp3", "wav", "aac"],
+                    value="mp3",
+                    label="Audio Format"
+                )
+                extract_btn = gr.Button("Extract Audio")
+            with gr.Column():
+                audio_output = gr.File(label="Extracted Audio")
+    
+    with gr.Tab("Video Thumbnail"):
+        with gr.Row():
+            with gr.Column():
+                thumbnail_input = gr.File(label="Upload Video")
+                time_pos = gr.Number(label="Time Position (seconds)", value=0)
+                thumbnail_btn = gr.Button("Generate Thumbnail")
+            with gr.Column():
+                thumbnail_output = gr.File(label="Video Thumbnail")
+    
+    with gr.Tab("File Compression"):
+        with gr.Row():
+            with gr.Column():
+                files_input = gr.File(label="Upload Files", file_count="multiple")
+                compression_format = gr.Dropdown(
+                    choices=["zip", "7z", "tar.gz", "tar.xz"],
+                    value="zip",
+                    label="Compression Format"
+                )
+                file_compression = gr.Slider(
+                    minimum=0,
+                    maximum=100,
+                    value=50,
+                    label="Compression Level (0: Fastest/Largest, 100: Slowest/Smallest)"
+                )
+                files_compress_btn = gr.Button("Compress Files")
+            with gr.Column():
+                files_output = gr.File(label="Compressed Files")
+
+    # Connect all interface components
+    image_convert_btn.click(convert_image, 
+                          inputs=[image_input, image_format, image_compression],
+                          outputs=image_output)
+    
+    resize_btn.click(resize_image,
+                    inputs=[resize_input, width, height, maintain_aspect],
+                    outputs=resize_output)
+    
+    crop_btn.click(crop_image,
+                   inputs=[crop_input, x1, y1, x2, y2],
+                   outputs=crop_output)
+    
+    watermark_btn.click(add_watermark,
+                       inputs=[watermark_input, watermark_text, position],
+                       outputs=watermark_output)
+    
+    video_compress_btn.click(compress_video,
+                           inputs=[video_input, compression_level],
+                           outputs=video_output)
+    
+    trim_btn.click(trim_video,
+                   inputs=[trim_input, start_time, end_time],
+                   outputs=trim_output)
+    
+    extract_btn.click(extract_audio,
+                     inputs=[audio_input, audio_format],
+                     outputs=audio_output)
+    
+    thumbnail_btn.click(generate_thumbnail,
+                       inputs=[thumbnail_input, time_pos],
+                       outputs=thumbnail_output)
+    
+    files_compress_btn.click(compress_files,
+                           inputs=[files_input, compression_format, file_compression],
+                           outputs=files_output)
+        
+
+if __name__ == "__main__":
+    app.launch()

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+Pillow
+py7zr
+ffmpeg-python