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

mini_toolkit/tools/image_watermarker.py

@@ -0,0 +1,63 @@
+import io
+
+import streamlit as st
+from PIL import Image, ImageDraw, ImageFont
+
+from core.ui import sanitize_filename
+
+POSITIONS = ["Bottom right", "Bottom left", "Top right", "Top left", "Center"]
+
+
+def _font(size: int) -> ImageFont.ImageFont:
+    for name in ("DejaVuSans-Bold.ttf", "DejaVuSans.ttf", "Arial.ttf", "arial.ttf"):
+        try:
+            return ImageFont.truetype(name, size)
+        except OSError:
+            continue
+    try:
+        return ImageFont.load_default(size=size)  # Pillow >= 10.1 ships a scalable default font
+    except TypeError:
+        return ImageFont.load_default()
+
+
+def watermark(image: Image.Image, text: str, size: int, opacity: int, color: str, position: str) -> Image.Image:
+    base = image.convert("RGBA")
+    layer = Image.new("RGBA", base.size, (0, 0, 0, 0))
+    draw = ImageDraw.Draw(layer)
+    font = _font(size)
+    left, top, right, bottom = draw.textbbox((0, 0), text, font=font)
+    w, h = right - left, bottom - top
+    margin = max(10, base.width // 50)
+    x = {"left": margin, "right": base.width - w - margin}.get(position.split()[-1], (base.width - w) / 2)
+    y = {"Top": margin, "Bottom": base.height - h - margin}.get(position.split()[0], (base.height - h) / 2)
+    rgb = tuple(int(color[i:i + 2], 16) for i in (1, 3, 5))
+    draw.text((x - left, y - top), text, font=font, fill=(*rgb, opacity))
+    return Image.alpha_composite(base, layer)
+
+
+def render() -> None:
+    uploaded = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg", "webp"], key="watermark_upload")
+    if not uploaded:
+        st.info("Upload an image to add a watermark.")
+        return
+
+    image = Image.open(uploaded)
+    settings, preview = st.columns([1, 2])
+    with settings:
+        text = st.text_input("Watermark text", "© Your Brand")
+        size = st.slider("Font size", 10, 300, max(24, image.width // 20))
+        opacity = st.slider("Opacity", 0, 255, 140)
+        color = st.color_picker("Colour", "#FFFFFF")
+        position = st.selectbox("Position", POSITIONS)
+
+    if not text.strip():
+        preview.image(image, caption="Original", width="stretch")
+        return
+
+    result = watermark(image, text, size, opacity, color, position)
+    preview.image(result, caption="Preview", width="stretch")
+    buf = io.BytesIO()
+    result.save(buf, format="PNG")
+    settings.download_button(
+        "Download PNG", buf.getvalue(), f"{sanitize_filename(uploaded.name)}_watermarked.png", "image/png", type="primary"
+    )

mini_toolkit/tools/ocr.py

@@ -0,0 +1,93 @@
+"""OCR with Tesseract (default) and EasyOCR (optional, heavier) engines."""
+import os
+import platform
+import shutil
+
+import streamlit as st
+
+from core.ui import missing_dependency, sanitize_filename
+
+TESSERACT_LANGS = {"English": "eng", "Bengali": "ben", "Hindi": "hin"}
+
+
+def _find_tesseract():
+    if platform.system() != "Windows":
+        return shutil.which("tesseract")
+    for path in (
+        r"C:\Program Files\Tesseract-OCR\tesseract.exe",
+        r"C:\Program Files (x86)\Tesseract-OCR\tesseract.exe",
+        os.path.expanduser(r"~\AppData\Local\Programs\Tesseract-OCR\tesseract.exe"),
+    ):
+        if os.path.exists(path):
+            return path
+    return shutil.which("tesseract")
+
+
+@st.cache_data(show_spinner=False)
+def run_tesseract(image_bytes: bytes, langs: str) -> str:
+    import cv2
+    import numpy as np
+    import pytesseract
+
+    pytesseract.pytesseract.tesseract_cmd = _find_tesseract()
+    image = cv2.imdecode(np.frombuffer(image_bytes, np.uint8), cv2.IMREAD_GRAYSCALE)
+    # Otsu binarisation noticeably improves Tesseract accuracy on photos and screenshots.
+    _, binary = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
+    return pytesseract.image_to_string(binary, lang=langs)
+
+
+@st.cache_resource(show_spinner="Loading EasyOCR model (first run only)…")
+def _easyocr_reader():
+    import easyocr
+
+    return easyocr.Reader(["en", "bn"], gpu=False)
+
+
+@st.cache_data(show_spinner=False)
+def run_easyocr(image_bytes: bytes) -> str:
+    return "\n".join(text for _, text, _ in _easyocr_reader().readtext(image_bytes))
+
+
+def _easyocr_available() -> bool:
+    try:
+        import easyocr  # noqa: F401
+    except ImportError:
+        return False
+    return True
+
+
+def render() -> None:
+    engines = ["Tesseract"] + (["EasyOCR"] if _easyocr_available() else [])
+    cols = st.columns(2)
+    engine = cols[0].radio("Engine", engines, horizontal=True)
+    langs = []
+    if engine == "Tesseract":
+        langs = cols[1].multiselect("Languages", list(TESSERACT_LANGS), default=["English"])
+
+    uploaded = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg", "bmp", "tiff", "webp"], key="ocr_upload")
+    if not uploaded:
+        st.info("Upload an image containing text.")
+        return
+
+    if engine == "Tesseract" and not _find_tesseract():
+        missing_dependency("tesseract-ocr", "Install it from https://github.com/UB-Mannheim/tesseract/wiki (Windows) "
+                                            "or your package manager, then restart the app.")
+        return
+
+    image_bytes = uploaded.getvalue()
+    left, right = st.columns(2)
+    left.image(image_bytes, width="stretch")
+    with right, st.spinner("Extracting text…"):
+        try:
+            if engine == "Tesseract":
+                text = run_tesseract(image_bytes, "+".join(TESSERACT_LANGS[l] for l in langs) or "eng")
+            else:
+                text = run_easyocr(image_bytes)
+        except Exception as exc:
+            st.error(f"OCR failed: {exc}")
+            return
+        if not text.strip():
+            st.warning("No text was detected in this image.")
+            return
+        st.text_area("Extracted text", text, height=320)
+        st.download_button("Download .txt", text.encode("utf-8"), f"{sanitize_filename(uploaded.name)}.txt", "text/plain")

mini_toolkit/tools/page_speed.py

@@ -0,0 +1,45 @@
+import time
+
+import streamlit as st
+
+from core.net import fetch
+
+
+def measure(url: str) -> dict:
+    start = time.perf_counter()
+    response = fetch(url, timeout=20, stream=True)
+    first_byte = time.perf_counter() - start
+    size = sum(len(chunk) for chunk in response.iter_content(64 * 1024))
+    total = time.perf_counter() - start
+    return {"status": response.status_code, "ttfb": first_byte, "total": total, "size": size}
+
+
+def render() -> None:
+    url = st.text_input("Website URL", placeholder="https://example.com")
+    runs = st.slider("Number of runs (results are averaged)", 1, 5, 3)
+    if not st.button("Measure", type="primary", disabled=not url.strip()):
+        st.caption("Measures the HTML document only — not images, scripts or rendering time.")
+        return
+
+    results = []
+    with st.spinner("Measuring…"):
+        for _ in range(runs):
+            try:
+                results.append(measure(url))
+            except Exception as exc:
+                st.error(f"Request failed: {exc}")
+                return
+
+    avg = lambda key: sum(r[key] for r in results) / len(results)  # noqa: E731
+    total = avg("total")
+    cols = st.columns(4)
+    cols[0].metric("HTTP status", results[-1]["status"])
+    cols[1].metric("Time to first byte", f"{avg('ttfb') * 1000:.0f} ms")
+    cols[2].metric("Total download", f"{total * 1000:.0f} ms")
+    cols[3].metric("HTML size", f"{results[-1]['size'] / 1024:.1f} KB")
+    if total < 0.8:
+        st.success("Fast — the server responds quickly.")
+    elif total < 2:
+        st.warning("Moderate — there may be room to improve server response time.")
+    else:
+        st.error("Slow — consider caching, a CDN, or reducing server work.")

mini_toolkit/tools/password_checker.py

@@ -0,0 +1,53 @@
+import math
+import re
+import secrets
+import string
+
+import streamlit as st
+
+COMMON = {"password", "123456", "12345678", "qwerty", "abc123", "111111", "letmein", "welcome", "admin", "iloveyou", "monkey", "dragon"}
+
+CHECKS = [
+    (lambda p: len(p) >= 12, "Use at least 12 characters."),
+    (lambda p: re.search(r"[A-Z]", p), "Add an uppercase letter."),
+    (lambda p: re.search(r"[a-z]", p), "Add a lowercase letter."),
+    (lambda p: re.search(r"\d", p), "Add a number."),
+    (lambda p: re.search(r"[^A-Za-z0-9]", p), "Add a symbol."),
+    (lambda p: not re.search(r"(.)\1{2,}", p), "Avoid repeating the same character."),
+]
+
+LEVELS = [(28, "Very weak", "error"), (36, "Weak", "error"), (60, "Reasonable", "warning"), (80, "Strong", "success"), (math.inf, "Very strong", "success")]
+
+
+def entropy_bits(password: str) -> float:
+    pool = sum(size for pattern, size in ((r"[a-z]", 26), (r"[A-Z]", 26), (r"\d", 10), (r"[^A-Za-z0-9]", 32)) if re.search(pattern, password))
+    return len(password) * math.log2(pool) if pool else 0.0
+
+
+def generate(length: int) -> str:
+    alphabet = string.ascii_letters + string.digits + "!@#$%^&*-_=+"
+    while True:
+        pw = "".join(secrets.choice(alphabet) for _ in range(length))
+        if all(check(pw) for check, _ in CHECKS):
+            return pw
+
+
+def render() -> None:
+    st.caption("Your password is analysed in this session only and never stored.")
+    password = st.text_input("Password", type="password")
+    if password:
+        bits = 0.0 if password.lower() in COMMON else entropy_bits(password)
+        label, kind = next((lbl, k) for limit, lbl, k in LEVELS if bits < limit)
+        st.progress(min(bits / 100, 1.0))
+        getattr(st, kind)(f"**{label}** — about {bits:.0f} bits of entropy.")
+        if password.lower() in COMMON:
+            st.error("This is one of the most common passwords. Don't use it.")
+        tips = [tip for check, tip in CHECKS if not check(password)]
+        for tip in tips:
+            st.markdown(f"- {tip}")
+
+    st.divider()
+    st.markdown("**Need a strong one?**")
+    length = st.slider("Length", 12, 64, 20)
+    if st.button("Generate password"):
+        st.code(generate(length), language=None)

mini_toolkit/tools/pdf_tools.py

@@ -0,0 +1,83 @@
+import io
+
+import streamlit as st
+
+from core.ui import build_zip, missing_dependency, sanitize_filename
+
+
+def merge(files) -> bytes:
+    from pypdf import PdfWriter
+
+    writer = PdfWriter()
+    for f in files:
+        writer.append(io.BytesIO(f.getvalue()))
+    buf = io.BytesIO()
+    writer.write(buf)
+    return buf.getvalue()
+
+
+def extract(reader, pages) -> bytes:
+    from pypdf import PdfWriter
+
+    writer = PdfWriter()
+    for index in pages:
+        writer.add_page(reader.pages[index])
+    buf = io.BytesIO()
+    writer.write(buf)
+    return buf.getvalue()
+
+
+def _render_merge() -> None:
+    files = st.file_uploader("Upload PDFs (merged in upload order)", type="pdf", accept_multiple_files=True, key="pdf_merge")
+    if not files or len(files) < 2:
+        st.info("Upload two or more PDF files to merge.")
+        return
+    st.caption(" → ".join(f.name for f in files))
+    if st.button("Merge PDFs", type="primary"):
+        try:
+            st.download_button("Download merged PDF", merge(files), "merged.pdf", "application/pdf")
+        except Exception as exc:
+            st.error(f"Could not merge: {exc}")
+
+
+def _render_split() -> None:
+    from pypdf import PdfReader
+
+    uploaded = st.file_uploader("Upload a PDF", type="pdf", key="pdf_split")
+    if not uploaded:
+        st.info("Upload a PDF to split.")
+        return
+    try:
+        reader = PdfReader(io.BytesIO(uploaded.getvalue()))
+    except Exception as exc:
+        st.error(f"Could not read PDF: {exc}")
+        return
+    total = len(reader.pages)
+    stem = sanitize_filename(uploaded.name)
+    st.caption(f"{total} page{'s' if total != 1 else ''}")
+
+    mode = st.radio("Split mode", ["Extract a page range", "Every page as a separate file"], horizontal=True)
+    if mode == "Extract a page range":
+        left, right = st.columns(2)
+        start = left.number_input("From page", 1, total, 1)
+        end = right.number_input("To page", int(start), total, total)
+        if st.button("Extract pages", type="primary"):
+            data = extract(reader, range(int(start) - 1, int(end)))
+            st.download_button(f"Download pages {start}–{end}", data, f"{stem}_p{start}-{end}.pdf", "application/pdf")
+    elif st.button("Split all pages", type="primary"):
+        with st.spinner("Splitting…"):
+            pages = [(f"{stem}_page_{i + 1}.pdf", extract(reader, [i])) for i in range(total)]
+        st.download_button("Download pages (ZIP)", build_zip(pages), f"{stem}_pages.zip", "application/zip")
+
+
+def render() -> None:
+    try:
+        import pypdf  # noqa: F401
+    except ImportError:
+        missing_dependency("pypdf")
+        return
+    merge_tab, split_tab = st.tabs(["Merge", "Split"])
+    with merge_tab:
+        _render_merge()
+    with split_tab:
+        _render_split()

mini_toolkit/tools/qr_code.py

@@ -0,0 +1,83 @@
+import io
+
+import qrcode
+import streamlit as st
+from PIL import Image, ImageChops
+from qrcode.constants import ERROR_CORRECT_H, ERROR_CORRECT_L, ERROR_CORRECT_M, ERROR_CORRECT_Q
+
+ERROR_LEVELS = {
+    "Low (7%)": ERROR_CORRECT_L,
+    "Medium (15%)": ERROR_CORRECT_M,
+    "Quartile (25%)": ERROR_CORRECT_Q,
+    "High (30%)": ERROR_CORRECT_H,
+}
+
+
+def _escape_wifi(value: str) -> str:
+    for ch in ("\\", ";", ",", ":", '"'):
+        value = value.replace(ch, "\\" + ch)
+    return value
+
+
+def build_qr(data: str, fg: str, bg: str, transparent: bool, size: int, error_level: int) -> bytes:
+    qr = qrcode.QRCode(error_correction=error_level, box_size=10, border=4)
+    qr.add_data(data)
+    qr.make(fit=True)
+    img = qr.make_image(fill_color=fg, back_color=bg).convert("RGBA")
+    if transparent:
+        # Alpha = 0 wherever the pixel matches the background colour.
+        solid_bg = Image.new("RGB", img.size, bg)
+        alpha = ImageChops.difference(img.convert("RGB"), solid_bg).convert("L").point(lambda v: 255 if v else 0)
+        img.putalpha(alpha)
+    img = img.resize((size, size), Image.NEAREST)
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    return buf.getvalue()
+
+
+def _payload(kind: str) -> str:
+    if kind == "Text / URL":
+        return st.text_area("Text or URL", placeholder="https://example.com", key="qr_text")
+    if kind == "Contact (vCard)":
+        left, right = st.columns(2)
+        name = left.text_input("Full name")
+        phone = left.text_input("Phone")
+        email = left.text_input("Email")
+        org = right.text_input("Organisation")
+        title = right.text_input("Job title")
+        url = right.text_input("Website")
+        if not any((name, phone, email, org, title, url)):
+            return ""
+        return "\n".join([
+            "BEGIN:VCARD", "VERSION:3.0", f"FN:{name}", f"N:{name}", f"ORG:{org}", f"TITLE:{title}",
+            f"TEL:{phone}", f"EMAIL:{email}", f"URL:{url}", "END:VCARD",
+        ])
+    left, right = st.columns(2)
+    ssid = left.text_input("Network name (SSID)")
+    password = right.text_input("Password", type="password")
+    security = left.selectbox("Security", ["WPA", "WEP", "nopass"])
+    hidden = right.checkbox("Hidden network")
+    if not ssid:
+        return ""
+    return f"WIFI:T:{security};S:{_escape_wifi(ssid)};P:{_escape_wifi(password)};H:{'true' if hidden else 'false'};;"
+
+
+def render() -> None:
+    kind = st.radio("Content type", ["Text / URL", "Contact (vCard)", "Wi-Fi"], horizontal=True)
+    data = _payload(kind)
+
+    with st.expander("Appearance"):
+        cols = st.columns(4)
+        fg = cols[0].color_picker("Foreground", "#000000")
+        bg = cols[1].color_picker("Background", "#FFFFFF")
+        size = cols[2].slider("Size (px)", 200, 1000, 400, 50)
+        level = cols[3].selectbox("Error correction", list(ERROR_LEVELS), index=1)
+        transparent = st.checkbox("Transparent background")
+
+    if not data.strip():
+        st.info("Enter some content to generate a QR code.")
+        return
+
+    png = build_qr(data, fg, bg, transparent, size, ERROR_LEVELS[level])
+    st.image(png, width=min(size, 400))
+    st.download_button("Download PNG", png, "qr_code.png", "image/png", type="primary")