streamlit-mini-toolkit 0.1.0__py3-none-any.whl

mini_toolkit/tools/change_tracker.py

@@ -0,0 +1,90 @@
+"""Compare a page's visible text with the snapshot taken on the previous check.
+
+Snapshots live in the system temp directory, so on hosted platforms they last
+only as long as the server instance. Email summaries are sent when SMTP
+credentials are configured in Streamlit secrets (see README).
+"""
+import difflib
+import hashlib
+import smtplib
+import tempfile
+from datetime import datetime
+from email.mime.text import MIMEText
+from pathlib import Path
+
+import streamlit as st
+from bs4 import BeautifulSoup
+
+from core.net import fetch, normalize_url
+
+SNAPSHOT_DIR = Path(tempfile.gettempdir()) / "mini_toolkit_snapshots"
+SMTP_KEYS = ("smtp_server", "smtp_port", "smtp_user", "smtp_pass")
+
+
+def page_text(url: str) -> str:
+    soup = BeautifulSoup(fetch(url, timeout=15).text, "html.parser")
+    for tag in soup(["script", "style", "noscript"]):
+        tag.decompose()
+    return "\n".join(line.strip() for line in soup.get_text("\n").splitlines() if line.strip())
+
+
+def snapshot_path(url: str) -> Path:
+    return SNAPSHOT_DIR / f"{hashlib.sha256(url.encode()).hexdigest()[:24]}.txt"
+
+
+def smtp_configured() -> bool:
+    try:
+        return all(key in st.secrets for key in SMTP_KEYS)
+    except Exception:  # no secrets file at all
+        return False
+
+
+def send_email(to: str, subject: str, body: str) -> None:
+    msg = MIMEText(body)
+    msg["Subject"], msg["From"], msg["To"] = subject, st.secrets["smtp_user"], to
+    with smtplib.SMTP(st.secrets["smtp_server"], int(st.secrets["smtp_port"]), timeout=15) as server:
+        server.starttls()
+        server.login(st.secrets["smtp_user"], st.secrets["smtp_pass"])
+        server.send_message(msg)
+
+
+def render() -> None:
+    url = normalize_url(st.text_input("Page URL", placeholder="https://example.com/pricing"))
+    email = st.text_input("Email a summary to (optional)", disabled=not smtp_configured(),
+                          help=None if smtp_configured() else "Email is disabled: no SMTP credentials are configured on this server.")
+    if not st.button("Check for changes", type="primary", disabled=not url):
+        st.caption("The first check saves a snapshot; later checks show what changed since then.")
+        return
+
+    with st.spinner("Fetching page…"):
+        try:
+            current = page_text(url)
+        except Exception as exc:
+            st.error(f"Could not fetch page: {exc}")
+            return
+
+    path = snapshot_path(url)
+    previous = path.read_text(encoding="utf-8") if path.exists() else None
+    SNAPSHOT_DIR.mkdir(parents=True, exist_ok=True)
+    path.write_text(current, encoding="utf-8")
+
+    if previous is None:
+        st.info("Snapshot saved. Run the check again later to see changes.")
+        return
+    diff = list(difflib.unified_diff(previous.splitlines(), current.splitlines(), "before", "after", lineterm="", n=1))
+    if not diff:
+        st.success("No changes since the last check.")
+        return
+
+    added = sum(1 for line in diff if line.startswith("+") and not line.startswith("+++"))
+    removed = sum(1 for line in diff if line.startswith("-") and not line.startswith("---"))
+    st.warning(f"Page changed: {added} line(s) added, {removed} removed.")
+    summary = "\n".join(diff[:200])
+    st.code(summary, language="diff")
+
+    if email:
+        try:
+            send_email(email, f"Change detected: {url}", f"Checked {datetime.now():%Y-%m-%d %H:%M}\n\n{summary}")
+            st.success(f"Summary emailed to {email}.")
+        except Exception as exc:
+            st.error(f"Could not send email: {exc}")

mini_toolkit/tools/chat_alert.py

@@ -0,0 +1,42 @@
+from urllib.parse import urlparse
+
+import requests
+import streamlit as st
+
+# Webhooks may only point at these services, so the tool can't be used to POST to arbitrary hosts.
+PLATFORMS = {
+    "Slack": (("hooks.slack.com",), lambda msg: {"text": msg}),
+    "Microsoft Teams": ((".webhook.office.com", ".logic.azure.com", "outlook.office.com"), lambda msg: {"text": msg}),
+    "Discord": (("discord.com", "discordapp.com"), lambda msg: {"content": msg}),
+}
+
+
+def allowed(url: str, hosts) -> bool:
+    parsed = urlparse(url)
+    host = parsed.hostname or ""
+    return parsed.scheme == "https" and any(host == h or host.endswith(h if h.startswith(".") else "." + h) for h in hosts)
+
+
+def send(platform: str, webhook: str, message: str) -> requests.Response:
+    _, payload = PLATFORMS[platform]
+    return requests.post(webhook, json=payload(message), timeout=10)
+
+
+def render() -> None:
+    platform = st.radio("Platform", list(PLATFORMS), horizontal=True)
+    webhook = st.text_input("Incoming webhook URL", type="password", help="Treated like a secret — it is never stored.").strip()
+    message = st.text_area("Message", placeholder="Deploy finished ✅")
+
+    if st.button("Send", type="primary", disabled=not (webhook and message.strip())):
+        if not allowed(webhook, PLATFORMS[platform][0]):
+            st.error(f"That doesn't look like a {platform} webhook URL.")
+            return
+        try:
+            response = send(platform, webhook, message)
+        except requests.RequestException as exc:
+            st.error(f"Request failed: {exc}")
+            return
+        if response.ok:
+            st.success(f"Message sent to {platform}.")
+        else:
+            st.error(f"{platform} rejected the message ({response.status_code}): {response.text[:200]}")

mini_toolkit/tools/color_picker.py

@@ -0,0 +1,40 @@
+import streamlit as st
+from PIL import Image
+
+from core.ui import missing_dependency
+
+DISPLAY_WIDTH = 700
+
+
+def render() -> None:
+    try:
+        from streamlit_image_coordinates import streamlit_image_coordinates
+    except ImportError:
+        missing_dependency("streamlit-image-coordinates")
+        return
+
+    uploaded = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg", "bmp", "webp"], key="color_picker_upload")
+    if not uploaded:
+        st.info("Upload an image, then click anywhere on it to sample a colour.")
+        return
+
+    image = Image.open(uploaded).convert("RGB")
+    width = min(image.width, DISPLAY_WIDTH)
+    st.caption("Click on the image to pick a colour.")
+    coords = streamlit_image_coordinates(image, width=width, key="color_picker_coords")
+    if not coords:
+        return
+
+    # The image may be displayed scaled down, so map the click back to source pixels.
+    scale = image.width / width
+    x = min(int(coords["x"] * scale), image.width - 1)
+    y = min(int(coords["y"] * scale), image.height - 1)
+    r, g, b = image.getpixel((x, y))
+    hex_code = f"#{r:02X}{g:02X}{b:02X}"
+
+    swatch, values = st.columns([1, 3])
+    swatch.markdown(f"<div class='color-swatch' style='background:{hex_code}'></div>", unsafe_allow_html=True)
+    with values:
+        st.caption(f"Pixel ({x}, {y})")
+        st.code(hex_code, language=None)
+        st.code(f"rgb({r}, {g}, {b})", language=None)

mini_toolkit/tools/document_converter.py

@@ -0,0 +1,121 @@
+import io
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+import streamlit as st
+
+from core.pdf import pdf_safe
+from core.ui import missing_dependency, sanitize_filename
+
+PDF_MIME = "application/pdf"
+DOCX_MIME = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+
+# Conversion label -> (input extension, output extension, output MIME)
+CONVERSIONS = {
+    "DOCX → PDF": ("docx", "pdf", PDF_MIME),
+    "PDF → DOCX": ("pdf", "docx", DOCX_MIME),
+    "PDF → TXT": ("pdf", "txt", "text/plain"),
+    "DOCX → TXT": ("docx", "txt", "text/plain"),
+    "TXT → PDF": ("txt", "pdf", PDF_MIME),
+}
+
+
+def docx_to_pdf(data: bytes, filename: str) -> bytes:
+    with tempfile.TemporaryDirectory() as tmp:
+        src = Path(tmp) / filename
+        src.write_bytes(data)
+        office = shutil.which("libreoffice") or shutil.which("soffice")
+        if office:
+            subprocess.run([office, "--headless", "--convert-to", "pdf", "--outdir", tmp, str(src)],
+                           check=True, timeout=120, capture_output=True)
+            return src.with_suffix(".pdf").read_bytes()
+        # Fallback for Windows/macOS machines with Microsoft Word installed.
+        from docx2pdf import convert
+
+        try:
+            import pythoncom
+            pythoncom.CoInitialize()
+        except ImportError:
+            pass
+        out = Path(tmp) / "output.pdf"
+        convert(str(src), str(out))
+        return out.read_bytes()
+
+
+def pdf_to_docx(data: bytes) -> bytes:
+    from pdf2docx import Converter
+
+    with tempfile.TemporaryDirectory() as tmp:
+        src, out = Path(tmp) / "input.pdf", Path(tmp) / "output.docx"
+        src.write_bytes(data)
+        converter = Converter(str(src))
+        try:
+            converter.convert(str(out))
+        finally:
+            converter.close()
+        return out.read_bytes()
+
+
+def pdf_to_txt(data: bytes) -> bytes:
+    from pypdf import PdfReader
+
+    reader = PdfReader(io.BytesIO(data))
+    return "\n\n".join(page.extract_text() or "" for page in reader.pages).encode("utf-8")
+
+
+def docx_to_txt(data: bytes) -> bytes:
+    from docx import Document
+
+    return "\n".join(p.text for p in Document(io.BytesIO(data)).paragraphs).encode("utf-8")
+
+
+def txt_to_pdf(data: bytes) -> bytes:
+    from fpdf import FPDF
+
+    text = data.decode("utf-8", errors="replace")
+    pdf = FPDF()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    pdf.add_page()
+    pdf.set_font("Helvetica", size=11)
+    pdf.multi_cell(0, 6, pdf_safe(text))
+    return bytes(pdf.output())
+
+
+def convert(label: str, data: bytes, filename: str) -> bytes:
+    if label == "DOCX → PDF":
+        return docx_to_pdf(data, filename)
+    if label == "PDF → DOCX":
+        return pdf_to_docx(data)
+    if label == "PDF → TXT":
+        return pdf_to_txt(data)
+    if label == "DOCX → TXT":
+        return docx_to_txt(data)
+    return txt_to_pdf(data)
+
+
+def render() -> None:
+    label = st.radio("Conversion", list(CONVERSIONS), horizontal=True)
+    src_ext, out_ext, mime = CONVERSIONS[label]
+    uploaded = st.file_uploader(f"Upload a .{src_ext} file", type=[src_ext], key=f"docconv_{src_ext}")
+    if not uploaded:
+        st.info("Upload a file to convert.")
+        return
+
+    with st.spinner("Converting…"):
+        try:
+            result = convert(label, uploaded.getvalue(), uploaded.name)
+        except ImportError as exc:
+            missing_dependency(exc.name or str(exc))
+            return
+        except Exception as exc:
+            st.error(f"Conversion failed: {exc}")
+            if label == "DOCX → PDF":
+                st.caption("DOCX → PDF needs LibreOffice on the server, or Microsoft Word locally.")
+            return
+
+    st.success("Conversion complete.")
+    if out_ext == "txt":
+        st.text_area("Preview", result.decode("utf-8", errors="replace")[:5000], height=240)
+    st.download_button(f"Download .{out_ext}", result, f"{sanitize_filename(uploaded.name)}.{out_ext}", mime, type="primary")

mini_toolkit/tools/file_compressor.py

@@ -0,0 +1,78 @@
+import io
+from pathlib import Path
+
+import streamlit as st
+from PIL import Image
+
+from core.ui import build_zip, image_uploader
+
+QUALITY = {"Smallest file": 35, "Balanced": 65, "Best quality": 85}
+
+
+def shrink(f, quality: int, max_side: int) -> tuple:
+    """Re-encode an image smaller. Returns (filename, bytes)."""
+    image = Image.open(f)
+    if max_side and max(image.size) > max_side:
+        image.thumbnail((max_side, max_side))
+    buf = io.BytesIO()
+    suffix = Path(f.name).suffix.lower()
+    if suffix == ".png" and image.mode in ("RGBA", "LA", "P"):
+        image.save(buf, format="PNG", optimize=True)
+        name = f.name
+    elif suffix == ".webp":
+        image.save(buf, format="WEBP", quality=quality)
+        name = f.name
+    else:
+        image.convert("RGB").save(buf, format="JPEG", quality=quality, optimize=True)
+        name = f"{Path(f.name).stem}.jpg"
+    return name, buf.getvalue()
+
+
+def _render_zip() -> None:
+    files = st.file_uploader("Upload any files", accept_multiple_files=True, key="zip_upload")
+    if not files:
+        st.info("Upload files to bundle into a ZIP archive.")
+        return
+    data = build_zip((f.name, f.getvalue()) for f in files)
+    original = sum(f.size for f in files)
+    st.metric("Archive size", f"{len(data) / 1024:.1f} KB", f"{(len(data) - original) / max(original, 1):+.0%}", delta_color="inverse")
+    st.download_button("Download ZIP", data, "archive.zip", "application/zip", type="primary")
+
+
+def _render_images() -> None:
+    left, right = st.columns(2)
+    quality = QUALITY[left.radio("Quality", list(QUALITY), index=1, horizontal=True)]
+    max_side = right.selectbox("Max dimension", [0, 3840, 2560, 1920, 1280, 800], format_func=lambda v: "Keep original" if v == 0 else f"{v}px")
+    files = image_uploader("shrink_upload", types=("png", "jpg", "jpeg", "webp"))
+    if not files:
+        st.info("Upload images to reduce their file size.")
+        return
+
+    outputs, before, after = [], 0, 0
+    for f in files:
+        try:
+            name, data = shrink(f, quality, max_side)
+        except Exception as exc:
+            st.warning(f"Skipped {f.name}: {exc}")
+            continue
+        outputs.append((name, data))
+        before += f.size
+        after += len(data)
+
+    if outputs:
+        cols = st.columns(3)
+        cols[0].metric("Before", f"{before / 1024:.0f} KB")
+        cols[1].metric("After", f"{after / 1024:.0f} KB")
+        cols[2].metric("Saved", f"{1 - after / max(before, 1):.0%}")
+        if len(outputs) == 1:
+            st.download_button("Download image", outputs[0][1], outputs[0][0], type="primary")
+        else:
+            st.download_button("Download all (ZIP)", build_zip(outputs), "compressed_images.zip", "application/zip", type="primary")
+
+
+def render() -> None:
+    images_tab, zip_tab = st.tabs(["Shrink images", "Create ZIP"])
+    with images_tab:
+        _render_images()
+    with zip_tab:
+        _render_zip()

mini_toolkit/tools/github_trending.py

@@ -0,0 +1,53 @@
+from datetime import date, timedelta
+
+import requests
+import streamlit as st
+
+PERIODS = {"Today": 1, "This week": 7, "This month": 30}
+
+
+@st.cache_data(ttl=900, show_spinner=False)
+def trending(days: int, language: str, limit: int = 20) -> list:
+    """Approximates GitHub Trending: most-starred repositories created in the window."""
+    query = f"created:>{date.today() - timedelta(days=days)}"
+    if language:
+        query += f" language:{language}"
+    response = requests.get(
+        "https://api.github.com/search/repositories",
+        params={"q": query, "sort": "stars", "order": "desc", "per_page": limit},
+        headers={"Accept": "application/vnd.github+json"},
+        timeout=15,
+    )
+    response.raise_for_status()
+    return response.json().get("items", [])
+
+
+def render() -> None:
+    left, right = st.columns(2)
+    period = left.selectbox("Created", list(PERIODS), index=1)
+    language = right.text_input("Language", placeholder="Any — e.g. python, rust").strip().lower()
+
+    with st.spinner("Fetching from GitHub…"):
+        try:
+            repos = trending(PERIODS[period], language)
+        except requests.HTTPError as exc:
+            if exc.response is not None and exc.response.status_code == 403:
+                st.error("GitHub's rate limit was reached. Try again in a minute.")
+            else:
+                st.error(f"GitHub request failed: {exc}")
+            return
+        except requests.RequestException as exc:
+            st.error(f"Could not reach GitHub: {exc}")
+            return
+
+    if not repos:
+        st.info("No repositories found. Try a longer period or another language.")
+        return
+    for repo in repos:
+        with st.container(border=True):
+            title, stars = st.columns([5, 1])
+            title.markdown(f"**[{repo['full_name']}]({repo['html_url']})**")
+            stars.markdown(f"⭐ {repo['stargazers_count']:,}")
+            if repo.get("description"):
+                st.write(repo["description"])
+            st.caption(" · ".join(filter(None, [repo.get("language"), f"{repo['forks_count']:,} forks"])))

mini_toolkit/tools/hash_generator.py

@@ -0,0 +1,43 @@
+import hashlib
+
+import streamlit as st
+
+ALGORITHMS = {
+    "MD5": hashlib.md5,
+    "SHA-1": hashlib.sha1,
+    "SHA-256": hashlib.sha256,
+    "SHA-512": hashlib.sha512,
+    "SHA3-256": hashlib.sha3_256,
+    "BLAKE2b": hashlib.blake2b,
+}
+
+
+def digest(data: bytes, algorithm: str) -> str:
+    return ALGORITHMS[algorithm](data).hexdigest()
+
+
+def render() -> None:
+    source = st.radio("Input", ["Text", "File"], horizontal=True)
+    if source == "Text":
+        text = st.text_area("Text to hash", height=120)
+        data = text.encode("utf-8") if text else None
+    else:
+        uploaded = st.file_uploader("File to hash", key="hash_file")
+        data = uploaded.getvalue() if uploaded else None
+
+    selected = st.multiselect("Algorithms", list(ALGORITHMS), default=["MD5", "SHA-256"])
+    if data is None:
+        st.info("Enter text or upload a file to compute its hash.")
+        return
+
+    for algorithm in selected:
+        st.caption(algorithm)
+        st.code(digest(data, algorithm), language=None)
+
+    expected = st.text_input("Verify against a known hash (optional)").strip().lower()
+    if expected:
+        match = next((a for a in selected if digest(data, a) == expected), None)
+        if match:
+            st.success(f"Match — the {match} hash is identical.")
+        else:
+            st.error("No match among the selected algorithms.")

mini_toolkit/tools/image_converter.py

@@ -0,0 +1,63 @@
+import io
+
+import streamlit as st
+from PIL import Image
+
+from core.ui import build_zip, image_uploader, sanitize_filename, section
+
+# Display label -> (Pillow format, extension, MIME type, supports alpha)
+FORMATS = {
+    "PNG": ("PNG", "png", "image/png", True),
+    "JPG": ("JPEG", "jpg", "image/jpeg", False),
+    "WEBP": ("WEBP", "webp", "image/webp", True),
+    "BMP": ("BMP", "bmp", "image/bmp", False),
+    "TIFF": ("TIFF", "tiff", "image/tiff", True),
+}
+
+
+def convert(image: Image.Image, label: str) -> bytes:
+    fmt, _, _, supports_alpha = FORMATS[label]
+    if not supports_alpha and image.mode in ("RGBA", "LA", "P"):
+        # Flatten transparency onto white instead of letting it turn black.
+        rgba = image.convert("RGBA")
+        background = Image.new("RGB", rgba.size, (255, 255, 255))
+        background.paste(rgba, mask=rgba.split()[-1])
+        image = background
+    elif not supports_alpha and image.mode != "RGB":
+        image = image.convert("RGB")
+    buf = io.BytesIO()
+    image.save(buf, format=fmt)
+    return buf.getvalue()
+
+
+def render() -> None:
+    target = st.radio("Convert to", list(FORMATS), horizontal=True)
+    files = image_uploader("converter_upload")
+    if not files:
+        st.info("Upload one or more images to convert.")
+        return
+
+    _, ext, mime, _ = FORMATS[target]
+    section("Converted images")
+    outputs = []
+    for i, f in enumerate(files):
+        try:
+            original = Image.open(f)
+            data = convert(original, target)
+        except Exception as exc:
+            st.error(f"Could not convert {f.name}: {exc}")
+            continue
+        name = f"{sanitize_filename(f.name)}.{ext}"
+        outputs.append((name, data))
+        with st.container(border=True):
+            cols = st.columns([1, 2])
+            cols[0].image(original, width="stretch")
+            cols[1].markdown(f"**{f.name}** → `{name}`")
+            cols[1].caption(
+                f"{original.format} · {original.width}×{original.height} · "
+                f"{f.size / 1024:.1f} KB → {len(data) / 1024:.1f} KB"
+            )
+            cols[1].download_button(f"Download {target}", data, name, mime, key=f"conv_dl_{i}")
+
+    if len(outputs) > 1:
+        st.download_button("Download all as ZIP", build_zip(outputs), "converted_images.zip", "application/zip", type="primary")

mini_toolkit/tools/image_downloader.py

@@ -0,0 +1,67 @@
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import PurePosixPath
+from urllib.parse import urljoin, urlparse
+
+import streamlit as st
+from bs4 import BeautifulSoup
+
+from core.net import fetch
+from core.ui import build_zip
+
+MAX_IMAGES = 60
+
+
+def find_images(url: str) -> list:
+    response = fetch(url, timeout=15)
+    soup = BeautifulSoup(response.text, "html.parser")
+    found = []
+    for img in soup.find_all("img"):
+        src = img.get("src") or img.get("data-src")
+        if src and not src.startswith("data:"):
+            found.append(urljoin(response.url, src))
+    return list(dict.fromkeys(found))
+
+
+def download(url: str):
+    try:
+        response = fetch(url, timeout=15)
+        if response.ok and response.headers.get("content-type", "").startswith("image/"):
+            return url, response.content
+    except Exception:
+        pass
+    return url, None
+
+
+def render() -> None:
+    url = st.text_input("Page URL", placeholder="https://example.com")
+    if st.button("Find images", type="primary", disabled=not url.strip()):
+        with st.spinner("Scanning page…"):
+            try:
+                st.session_state.img_dl_urls = find_images(url)[:MAX_IMAGES]
+            except Exception as exc:
+                st.error(f"Could not load page: {exc}")
+                return
+
+    urls = st.session_state.get("img_dl_urls")
+    if urls is None:
+        return
+    if not urls:
+        st.warning("No images found on that page.")
+        return
+
+    st.caption(f"Found {len(urls)} image{'s' if len(urls) != 1 else ''} (showing up to {MAX_IMAGES}).")
+    cols = st.columns(4)
+    for i, img_url in enumerate(urls):
+        cols[i % 4].image(img_url, width="stretch")
+
+    if st.button("Prepare ZIP download"):
+        with st.spinner("Downloading images…"), ThreadPoolExecutor(max_workers=8) as pool:
+            results = [(u, data) for u, data in pool.map(download, urls) if data]
+        entries, seen = [], set()
+        for i, (img_url, data) in enumerate(results):
+            name = PurePosixPath(urlparse(img_url).path).name or f"image_{i}"
+            if name in seen:
+                name = f"{i}_{name}"
+            seen.add(name)
+            entries.append((name, data))
+        st.download_button(f"Download {len(entries)} images (ZIP)", build_zip(entries), "images.zip", "application/zip", type="primary")

mini_toolkit/tools/image_enhancer.py

@@ -0,0 +1,54 @@
+import io
+
+import streamlit as st
+from PIL import Image, ImageEnhance
+
+from core.ui import build_zip, image_uploader, sanitize_filename, section
+
+
+def enhance(image: Image.Image, brightness: float, contrast: float, color: float, sharpness: float) -> Image.Image:
+    if image.mode not in ("RGB", "RGBA"):
+        image = image.convert("RGBA")
+    for enhancer, factor in (
+        (ImageEnhance.Brightness, brightness),
+        (ImageEnhance.Contrast, contrast),
+        (ImageEnhance.Color, color),
+        (ImageEnhance.Sharpness, sharpness),
+    ):
+        image = enhancer(image).enhance(factor)
+    return image
+
+
+def render() -> None:
+    cols = st.columns(4)
+    brightness = cols[0].slider("Brightness", 0.5, 2.0, 1.0, 0.05)
+    contrast = cols[1].slider("Contrast", 0.5, 2.0, 1.2, 0.05)
+    color = cols[2].slider("Colour", 0.5, 2.0, 1.0, 0.05)
+    sharpness = cols[3].slider("Sharpness", 0.5, 2.0, 1.2, 0.05)
+
+    files = image_uploader("enhancer_upload")
+    if not files:
+        st.info("Upload one or more images to enhance.")
+        return
+
+    section("Enhanced images")
+    outputs = []
+    for i, f in enumerate(files):
+        try:
+            original = Image.open(f)
+            result = enhance(original, brightness, contrast, color, sharpness)
+        except Exception as exc:
+            st.error(f"Could not enhance {f.name}: {exc}")
+            continue
+        buf = io.BytesIO()
+        result.save(buf, format="PNG")
+        name = f"{sanitize_filename(f.name)}_enhanced.png"
+        outputs.append((name, buf.getvalue()))
+        with st.container(border=True):
+            left, right = st.columns(2)
+            left.image(original, caption="Original", width="stretch")
+            right.image(result, caption="Enhanced", width="stretch")
+            st.download_button("Download PNG", buf.getvalue(), name, "image/png", key=f"enh_dl_{i}")
+
+    if len(outputs) > 1:
+        st.download_button("Download all as ZIP", build_zip(outputs), "enhanced_images.zip", "application/zip", type="primary")