Create app.py

app.py

@@ -0,0 +1,179 @@
+import streamlit as st
+from PIL import Image
+import os
+import io
+from tempfile import NamedTemporaryFile
+
+def compress_image(image_file, output_path, target_size_kb, quality=75, step=5, min_quality=10, status_area=None):
+    """
+    Compresses an image to a target file size while maintaining reasonable quality.
+
+    Args:
+        image_file: An in-memory file object of the input image (when handling single image) or path to image.
+        output_path: Path to save the compressed image.
+        target_size_kb: Desired file size in kilobytes (approximate).
+        quality: Initial quality setting for compression (0-100, higher is better).
+        step: Step size to adjust quality during optimization.
+        min_quality: Minimum acceptable quality.
+        status_area: streamlit text area element to update user status
+
+    Returns:
+        True if compression was successful within the constraints, False otherwise.
+    """
+
+    try:
+        if isinstance(image_file, str):  # Handle file paths
+            img = Image.open(image_file)
+        else:  # Handle in-memory file objects (e.g. uploaded files)
+            img = Image.open(image_file)
+    except FileNotFoundError:
+        status_area.write(f"Error: Image not found at {image_file}") if status_area else print(f"Error: Image not found at {image_file}")
+        return False
+    except Exception as e:
+        status_area.write(f"Error opening image: {e}") if status_area else print(f"Error opening image: {e}")
+        return False
+    
+    # Handle different image formats if needed
+    if img.format == "PNG":
+        # Convert PNG to RGB (remove alpha channel) to allow JPEG compression
+        if img.mode in ("RGBA", "LA") or (img.mode == "P" and "transparency" in img.info):
+            background = Image.new("RGB", img.size, (255, 255, 255))
+            background.paste(img, mask=img.split()[-1])
+            img = background
+
+    # Optimize for target size
+    while True:
+        try:
+            img.save(output_path, "JPEG", optimize=True, quality=quality)
+        except Exception as e:
+             status_area.write(f"Error saving image: {e}") if status_area else print(f"Error saving image: {e}")
+             return False
+        
+        file_size_kb = os.path.getsize(output_path) / 1024
+        
+        if file_size_kb <= target_size_kb or quality <= min_quality:
+            break
+
+        if file_size_kb > target_size_kb:
+            quality -= step
+            if quality < min_quality:
+                quality = min_quality
+    
+    if file_size_kb <= target_size_kb:
+        status_area.write(f"Image compressed to {file_size_kb:.2f}KB (quality={quality})") if status_area else print(f"Image compressed to {file_size_kb:.2f}KB (quality={quality})")
+        return True
+    else:
+        status_area.write(f"Could not compress below {target_size_kb}KB within quality constraints.") if status_area else print(f"Could not compress below {target_size_kb}KB within quality constraints.")
+        return False
+
+
+def batch_compress_images(files, output_dir, target_size_kb, status_area=None):
+    """
+    Compresses all images in a list.
+
+    Args:
+        files: A list of image file paths or in-memory files
+        output_dir: Directory to save compressed images.
+        target_size_kb: Target file size in kilobytes.
+         status_area: streamlit text area element to update user status
+    """
+    os.makedirs(output_dir, exist_ok=True)
+    
+    for file in files:
+       
+        if isinstance(file, str):
+           filename = os.path.basename(file)
+        else:
+             filename = file.name
+
+        if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+            output_path = os.path.join(output_dir, filename)
+            success = compress_image(file, output_path, target_size_kb, status_area=status_area)
+            if not success:
+                status_area.write(f"Failed to compress {filename}") if status_area else print(f"Failed to compress {filename}")
+        else:
+              status_area.write(f"Skipping non-image file: {filename}") if status_area else print(f"Skipping non-image file: {filename}")
+
+def main():
+    st.title("Image Compressor")
+
+    # Initialize session state
+    if "status_messages" not in st.session_state:
+        st.session_state.status_messages = []
+
+    status_area = st.empty() # Empty container to display status
+    
+    st.header("Single Image Compression")
+    uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
+    target_size_single = st.number_input("Target Size (KB)", value=100)
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        quality_single = st.number_input("Initial Quality", min_value=1, max_value=100, value=75)
+    with col2:
+        step_single = st.number_input("Quality Step", min_value=1, value=5)
+    with col3:
+       min_quality_single = st.number_input("Minimum Quality", min_value=1, max_value=100, value=10)
+
+    if uploaded_file:
+        if st.button("Compress Single Image"):
+          
+            with NamedTemporaryFile(suffix=os.path.splitext(uploaded_file.name)[1], delete=False) as tmp_file:
+              tmp_file.write(uploaded_file.getvalue())
+              tmp_file_path = tmp_file.name
+            
+            with NamedTemporaryFile(suffix=".jpg", delete=False) as temp_output_file:
+                
+                success = compress_image(
+                    tmp_file_path, 
+                    temp_output_file.name, 
+                    target_size_single,
+                    quality_single,
+                    step_single,
+                    min_quality_single,
+                    status_area
+                    )
+                if success:
+                   with open(temp_output_file.name, "rb") as f:
+                        st.download_button(
+                           label="Download Compressed Image",
+                           data=f,
+                           file_name=f"compressed_{os.path.splitext(uploaded_file.name)[0]}.jpg",
+                           mime="image/jpeg"
+                       )
+                os.remove(tmp_file_path)
+                os.remove(temp_output_file.name)
+
+    st.header("Batch Image Compression")
+    uploaded_files = st.file_uploader("Upload multiple images", type=["png", "jpg", "jpeg"], accept_multiple_files=True)
+    target_size_batch = st.number_input("Target Size for Batch (KB)", value=150)
+
+    if uploaded_files:
+        if st.button("Compress Batch Images"):
+          
+          temp_files = []
+          for file in uploaded_files:
+             with NamedTemporaryFile(suffix=os.path.splitext(file.name)[1], delete=False) as tmp_file:
+                tmp_file.write(file.getvalue())
+                temp_files.append(tmp_file.name)
+          
+          with tempfile.TemporaryDirectory() as temp_dir:
+             batch_compress_images(temp_files, temp_dir, target_size_batch, status_area)
+
+             for file in temp_files:
+                  os.remove(file)
+
+             for filename in os.listdir(temp_dir):
+                 with open(os.path.join(temp_dir,filename), "rb") as f:
+                    st.download_button(
+                        label=f"Download Compressed {filename}",
+                        data=f,
+                        file_name=f"compressed_{filename}",
+                       )
+    
+    
+    status_area.text_area("Status", value='\n'.join(st.session_state.status_messages), height=200)
+
+if __name__ == "__main__":
+    import tempfile
+    main()