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

mini_toolkit/tools/resume_builder.py

@@ -0,0 +1,385 @@
+import io
+import os
+import tempfile
+
+import streamlit as st
+from docx import Document
+from docx.shared import Inches
+from fpdf import FPDF, XPos, YPos
+
+from core.pdf import pdf_safe
+from core.ui import sanitize_filename
+
+DOCX_MIME = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+
+# --- Helper function to generate DOCX resume ---
+def generate_docx_resume(personal_info, experiences, educations, skills, profile_pic=None):
+    document = Document()
+
+    if profile_pic:
+        document.add_picture(profile_pic, width=Inches(1.5))
+
+    document.add_heading(personal_info['name'], level=1)
+    contact_p = document.add_paragraph()
+    contact_p.add_run(f"{personal_info['email']} | {personal_info['phone']} | {personal_info['linkedin']}")
+
+    if personal_info['summary']:
+        document.add_heading('Summary', level=2)
+        document.add_paragraph(personal_info['summary'])
+
+    if experiences:
+        document.add_heading('Experience', level=2)
+        for exp in experiences:
+            if exp['title'] and exp['company']:
+                p = document.add_paragraph()
+                p.add_run(exp['title']).bold = True
+                p.add_run(f" | {exp['company']}").italic = True
+                p.add_run(f"\n{exp['dates']}")
+                if exp['desc']:
+                    document.add_paragraph(exp['desc'], style='List Bullet')
+
+    if educations:
+        document.add_heading('Education', level=2)
+        for edu in educations:
+            if edu['degree'] and edu['school']:
+                p = document.add_paragraph()
+                p.add_run(edu['degree']).bold = True
+                p.add_run(f" | {edu['school']}")
+                p.add_run(f"\n{edu['dates']}")
+
+    if skills:
+        document.add_heading('Skills', level=2)
+        document.add_paragraph(skills)
+
+    doc_buffer = io.BytesIO()
+    document.save(doc_buffer)
+    doc_buffer.seek(0)
+    return doc_buffer
+
+# --- Helper function to generate PDF resume ---
+class PDF(FPDF):
+    def header(self): pass
+    def footer(self): pass
+
+    def normalize_text(self, text):
+        return super().normalize_text(pdf_safe(text))
+
+def generate_pdf_resume_classic(personal_info, experiences, educations, skills, profile_pic=None):
+    pdf = PDF('P', 'mm', 'A4')
+    pdf.add_page()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    pdf.set_font('helvetica', '', 12)
+
+    # --- Header Section ---
+    if profile_pic:
+        # Layout WITH profile picture
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
+            profile_pic.seek(0)
+            tmp.write(profile_pic.read())
+            tmp_path = tmp.name
+        
+        # Place image. Assuming W=H, image bottom is at y=12+33=45
+        pdf.image(tmp_path, x=15, y=12, w=33)
+        os.unlink(tmp_path) # Clean up the temp file
+
+        # Set cursor for text, to the right of the image
+        text_x_start = 15 + 33 + 5 # image_x + image_width + padding
+        pdf.set_xy(text_x_start, 18)
+        pdf.set_font('helvetica', 'B', 24)
+        pdf.cell(0, 10, personal_info['name'], align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+        
+        pdf.set_x(text_x_start) # Reset X to be next to image for the second line
+        pdf.set_font('helvetica', '', 12)
+        pdf.cell(0, 10, f"{personal_info['email']} | {personal_info['phone']} | {personal_info['linkedin']}", align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+        
+        pdf.set_y(50) # Set Y to be below the image for the next section
+    else:
+        # Layout WITHOUT profile picture (centered)
+        pdf.set_y(15)
+        pdf.set_font('helvetica', 'B', 24)
+        pdf.cell(0, 10, personal_info['name'], align='C', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+        pdf.set_font('helvetica', '', 12)
+        pdf.cell(0, 10, f"{personal_info['email']} | {personal_info['phone']} | {personal_info['linkedin']}", align='C', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+        pdf.ln(5)
+
+    if personal_info['summary']:
+        pdf.set_font('helvetica', 'B', 14)
+        pdf.cell(0, 10, 'Summary', align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+        pdf.set_font('helvetica', '', 12)
+        pdf.multi_cell(0, 5, personal_info['summary'])
+        pdf.ln(5)
+
+    if experiences:
+        pdf.set_font('helvetica', 'B', 14)
+        pdf.cell(0, 10, 'Experience', align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+        for exp in experiences:
+            if exp['title'] and exp['company']:
+                pdf.set_font('helvetica', 'B', 12)
+                pdf.cell(0, 5, f"{exp['title']} | {exp['company']}", align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+                pdf.set_font('helvetica', 'I', 12)
+                pdf.cell(0, 5, exp['dates'], align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+                if exp['desc']:
+                    # Using '*' instead of '•' to avoid Unicode errors with standard fonts
+                    pdf.set_font('helvetica', '', 12)
+                    pdf.multi_cell(0, 5, f"  * {exp['desc']}")
+                pdf.ln(3)
+
+    if educations:
+        pdf.set_font('helvetica', 'B', 14)
+        pdf.cell(0, 10, 'Education', align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+        for edu in educations:
+            if edu['degree'] and edu['school']:
+                pdf.set_font('helvetica', 'B', 12)
+                pdf.cell(0, 5, f"{edu['degree']} | {edu['school']}", align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+                pdf.set_font('helvetica', 'I', 12)
+                pdf.cell(0, 5, edu['dates'], align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+                pdf.ln(3)
+
+    if skills:
+        pdf.set_font('helvetica', 'B', 14)
+        pdf.cell(0, 10, 'Skills', align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+        pdf.set_font('helvetica', '', 12)
+        pdf.multi_cell(0, 5, skills)
+
+    # Use pdf.output() which returns bytes directly, no need for manual encoding.
+    return io.BytesIO(pdf.output())
+
+# --- Helper function to generate PDF resume (Modern Template) ---
+def generate_pdf_resume_modern(personal_info, experiences, educations, skills):
+    pdf = PDF('P', 'mm', 'A4')
+    pdf.add_page()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    
+    # --- Theme Colors ---
+    pdf.set_text_color(40, 40, 40) # Dark Gray
+    heading_color = (0, 86, 179) # Blue
+
+    # --- Header ---
+    pdf.set_y(20)
+    pdf.set_font('helvetica', 'B', 32)
+    pdf.cell(0, 12, personal_info['name'], align='C', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.set_font('helvetica', '', 11)
+    pdf.cell(0, 8, f"{personal_info['email']} | {personal_info['phone']} | {personal_info['linkedin']}", align='C', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.ln(8)
+    pdf.set_line_width(0.5)
+    pdf.set_draw_color(*heading_color)
+    pdf.line(x1=15, y1=pdf.get_y(), x2=195, y2=pdf.get_y())
+    pdf.ln(8)
+
+    # --- Helper to draw a section ---
+    def draw_section(title, content_func):
+        pdf.set_font('helvetica', 'B', 14)
+        pdf.set_text_color(*heading_color)
+        pdf.cell(0, 10, title.upper(), align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+        pdf.set_text_color(40, 40, 40)
+        pdf.set_font('helvetica', '', 11)
+        content_func()
+        pdf.ln(6)
+
+    # --- Summary Section ---
+    if personal_info['summary']:
+        draw_section('Summary', lambda: pdf.multi_cell(0, 6, personal_info['summary']))
+
+    # --- Experience Section ---
+    if experiences:
+        def exp_content():
+            for exp in experiences:
+                if exp['title'] and exp['company']:
+                    pdf.set_font('helvetica', 'B', 12)
+                    pdf.cell(0, 6, exp['title'], align='L')
+                    pdf.set_font('helvetica', '', 12)
+                    pdf.cell(0, 6, exp['dates'], align='R', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+
+                    pdf.set_font('helvetica', 'I', 12)
+                    pdf.cell(0, 6, exp['company'], align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+
+                    if exp['desc']:
+                        pdf.set_font('helvetica', '', 11)
+                        # Using '*' for bullet points for font compatibility
+                        pdf.multi_cell(0, 5, f"  * {exp['desc']}")
+                    pdf.ln(4)
+        draw_section('Experience', exp_content)
+
+    # --- Education Section ---
+    if educations:
+        def edu_content():
+            for edu in educations:
+                if edu['degree'] and edu['school']:
+                    pdf.set_font('helvetica', 'B', 12)
+                    pdf.cell(130, 6, edu['degree'], align='L')
+                    pdf.set_font('helvetica', '', 12)
+                    pdf.cell(0, 6, edu['dates'], align='R', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+
+                    pdf.set_font('helvetica', 'I', 12)
+                    pdf.cell(0, 6, edu['school'], align='L', new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+                    pdf.ln(4)
+        draw_section('Education', edu_content)
+
+    # --- Skills Section ---
+    if skills:
+        def skills_content():
+            skill_list = [s.strip() for s in skills.split(',')]
+            # We'll just use a multi-cell for simplicity here
+            pdf.multi_cell(0, 6, ", ".join(skill_list))
+        draw_section('Skills', skills_content)
+
+    return io.BytesIO(pdf.output())
+
+
+# --- Helper function to generate Cover Letter Text ---
+def generate_cover_letter_text(personal_info, skills, job_title, company_name):
+    from datetime import datetime
+    today_date = datetime.today().strftime('%B %d, %Y')
+
+    # Try to pick a few relevant skills to highlight.
+    skills_list = [s.strip() for s in skills.split(',')]
+    highlight_skills = ""
+    if len(skills_list) > 2:
+        highlight_skills = f"my skills in {skills_list[0]}, {skills_list[1]}, and {skills_list[2]}"
+    elif skills_list:
+        highlight_skills = f"my skills in {', '.join(skills_list)}"
+    else:
+        highlight_skills = "my relevant skills"
+
+    cover_letter = f"""{personal_info['name']}
+{personal_info['email']} | {personal_info['phone']}
+{personal_info['linkedin']}
+
+{today_date}
+
+Hiring Manager
+{company_name}
+
+Dear Hiring Manager,
+
+I am writing to express my enthusiastic interest in the {job_title} position at {company_name}. I am confident that my background and {highlight_skills} align perfectly with the requirements of this role.
+
+My professional summary, "{personal_info['summary']}", reflects my dedication and experience. I am particularly excited about the opportunity to contribute to your team and believe my passion for technology and problem-solving would make me a valuable asset.
+
+Thank you for considering my application. My resume is attached for your review, and I look forward to the possibility of discussing this exciting opportunity with you further.
+
+Sincerely,
+{personal_info['name']}
+"""
+    return cover_letter.strip()
+
+# --- Helper function to generate Cover Letter DOCX ---
+def generate_cover_letter_docx(cover_letter_text):
+    document = Document()
+    for para in cover_letter_text.split('\n'):
+        document.add_paragraph(para)
+    doc_buffer = io.BytesIO()
+    document.save(doc_buffer)
+    doc_buffer.seek(0)
+    return doc_buffer
+
+def render():
+    with st.expander("👤 Personal Information", expanded=True):
+        col1, col2 = st.columns(2)
+        name = col1.text_input("Full Name", placeholder="Jane Doe")
+        profile_pic_file = col1.file_uploader("Upload Profile Picture (optional)", type=['png', 'jpg', 'jpeg'])
+
+        email = col2.text_input("Email", placeholder="jane@example.com")
+        phone = col1.text_input("Phone", placeholder="+1 555 010 0100")
+        linkedin = col2.text_input("LinkedIn Profile URL", placeholder="linkedin.com/in/jane-doe")
+        summary = st.text_area("Summary / Objective", placeholder="Software engineer with 5 years of experience building…")
+    file_stem = sanitize_filename(name or "resume")
+    personal_info = {'name': name, 'email': email, 'phone': phone, 'linkedin': linkedin, 'summary': summary}
+
+    with st.expander("💼 Work Experience"):
+        if 'experiences' not in st.session_state:
+            st.session_state.experiences = [{'title': '', 'company': '', 'dates': '', 'desc': ''}]
+        for i, exp in enumerate(st.session_state.experiences):
+            st.divider()
+            exp['title'] = st.text_input("Job Title", exp['title'], key=f"exp_title_{i}")
+            exp['company'] = st.text_input("Company", exp['company'], key=f"exp_comp_{i}")
+            exp['dates'] = st.text_input("Dates (e.g., Jan 2020 - Present)", exp['dates'], key=f"exp_dates_{i}")
+            exp['desc'] = st.text_area("Description", exp['desc'], key=f"exp_desc_{i}")
+        if st.button("Add Another Experience", key="add_exp"):
+            st.session_state.experiences.append({'title': '', 'company': '', 'dates': '', 'desc': ''})
+            st.rerun()
+
+    with st.expander("🎓 Education"):
+        if 'educations' not in st.session_state:
+            st.session_state.educations = [{'degree': '', 'school': '', 'dates': ''}]
+        for i, edu in enumerate(st.session_state.educations):
+            st.divider()
+            edu['degree'] = st.text_input("Degree", edu['degree'], key=f"edu_degree_{i}")
+            edu['school'] = st.text_input("School / University", edu['school'], key=f"edu_school_{i}")
+            edu['dates'] = st.text_input("Dates (e.g., 2016 - 2020)", edu['dates'], key=f"edu_dates_{i}")
+        if st.button("Add Another Education", key="add_edu"):
+            st.session_state.educations.append({'degree': '', 'school': '', 'dates': ''})
+            st.rerun()
+
+    with st.expander("🛠️ Skills"):
+        skills = st.text_area("List your skills (comma-separated)", placeholder="Python, SQL, Docker")
+
+    # --- Cover Letter Section ---
+    with st.expander("✉️ Auto Cover Letter Generator"):
+        cl_job_title = st.text_input("Job Title for Cover Letter", key="cl_job_title")
+        cl_company_name = st.text_input("Company Name for Cover Letter", key="cl_company_name")
+        st.text_area("Paste Job Description Here (for your reference)", key="cl_job_desc", help="The text from the job description is not yet used to customize the letter, but is a planned feature.")
+
+        if st.button("Generate Cover Letter", key="gen_cl", width="stretch"):
+            if not all([cl_job_title, cl_company_name, name]):
+                st.warning("Please fill in your Name (in Personal Info), the Job Title, and Company Name to generate a cover letter.")
+            else:
+                with st.spinner("Generating cover letter..."):
+                    cover_letter_text = generate_cover_letter_text(
+                        personal_info, skills, cl_job_title, cl_company_name
+                    )
+                    st.session_state.cover_letter_text = cover_letter_text
+                    st.session_state.cover_letter_docx = generate_cover_letter_docx(cover_letter_text).getvalue()
+                st.success("Cover letter generated!")
+
+    if 'cover_letter_text' in st.session_state:
+        st.subheader("Generated Cover Letter Preview")
+        st.text_area("Preview", st.session_state.cover_letter_text, height=400, key="cl_preview", disabled=True)
+        
+        cl_col1, cl_col2 = st.columns(2)
+        
+        # TXT Download
+        cl_col1.download_button(
+            label="Download as TXT",
+            data=st.session_state.cover_letter_text.encode('utf-8'),
+            file_name=f"{file_stem}_Cover_Letter.txt",
+            mime="text/plain",
+            width="stretch"
+        )
+        
+        # DOCX Download
+        cl_col2.download_button(
+            label="Download as DOCX",
+            data=st.session_state.cover_letter_docx,
+            file_name=f"{file_stem}_Cover_Letter.docx",
+            mime=DOCX_MIME,
+            width="stretch"
+        )
+
+    st.divider()
+    
+    template = st.selectbox("Select Resume Template", ("Classic", "Modern"), help="Choose a layout for your generated PDF resume.")
+
+    if st.button(f"Generate {template} Resume", width="stretch", type="primary"):
+        valid_experiences = [exp for exp in st.session_state.experiences if exp['title']]
+        valid_educations = [edu for edu in st.session_state.educations if edu['degree']]
+        if not name:
+            st.warning("Please enter your name to generate the resume.")
+        else:
+            profile_pic_data = None
+            if profile_pic_file:
+                profile_pic_data = io.BytesIO(profile_pic_file.getvalue())
+
+            with st.spinner("Generating documents..."):
+                st.session_state.docx_file = generate_docx_resume(personal_info, valid_experiences, valid_educations, skills, profile_pic=profile_pic_data).getvalue()
+                # Dispatch to the correct PDF generator based on template selection
+                if template == "Classic":
+                    st.session_state.pdf_file = generate_pdf_resume_classic(personal_info, valid_experiences, valid_educations, skills, profile_pic=profile_pic_data).getvalue()
+                else: # Modern
+                    st.session_state.pdf_file = generate_pdf_resume_modern(personal_info, valid_experiences, valid_educations, skills).getvalue()
+            st.success("Resume generated successfully!")
+
+    if 'docx_file' in st.session_state and 'pdf_file' in st.session_state:
+        col1, col2 = st.columns(2)
+        col1.download_button("Download as DOCX", st.session_state.docx_file, f"{file_stem}_Resume.docx", DOCX_MIME, width="stretch")
+        col2.download_button("Download as PDF", st.session_state.pdf_file, f"{file_stem}_Resume.pdf", "application/pdf", width="stretch")

mini_toolkit/tools/seo_health.py

@@ -0,0 +1,64 @@
+from urllib.parse import urljoin
+
+import streamlit as st
+from bs4 import BeautifulSoup
+
+from core.net import fetch
+
+
+def _meta(soup, **attrs):
+    tag = soup.find("meta", attrs=attrs)
+    return (tag.get("content") or "").strip() if tag else ""
+
+
+def audit(url: str) -> tuple:
+    """Return (findings, details). Each finding is (passed, label, message)."""
+    response = fetch(url, timeout=15)
+    soup = BeautifulSoup(response.text, "html.parser")
+    title = soup.title.get_text(strip=True) if soup.title else ""
+    description = _meta(soup, name="description")
+    h1s = [h.get_text(" ", strip=True) for h in soup.find_all("h1")]
+    images = soup.find_all("img")
+    missing_alt = [img for img in images if not (img.get("alt") or "").strip()]
+    canonical = soup.find("link", rel="canonical")
+    html_tag = soup.find("html")
+
+    findings = [
+        (response.status_code == 200, "HTTP status", f"Returned {response.status_code}."),
+        (response.url.startswith("https://"), "HTTPS", "Served over HTTPS." if response.url.startswith("https://") else "Not served over HTTPS."),
+        (10 <= len(title) <= 60, "Title", f"{len(title)} characters (aim for 10–60)." if title else "Missing <title>."),
+        (50 <= len(description) <= 160, "Meta description", f"{len(description)} characters (aim for 50–160)." if description else "Missing meta description."),
+        (len(h1s) == 1, "H1 heading", f"{len(h1s)} found (aim for exactly one)."),
+        (not missing_alt, "Image alt text", f"{len(missing_alt)} of {len(images)} images missing alt text."),
+        (bool(_meta(soup, name="viewport")), "Mobile viewport", "Viewport meta tag present." if _meta(soup, name="viewport") else "No viewport meta tag."),
+        (canonical is not None, "Canonical URL", "Canonical link present." if canonical else "No canonical link."),
+        (bool(html_tag and html_tag.get("lang")), "Language", f"lang=\"{html_tag.get('lang')}\"" if html_tag and html_tag.get("lang") else "No lang attribute on <html>."),
+        (bool(_meta(soup, property="og:title")), "Open Graph", "og:title present." if _meta(soup, property="og:title") else "No Open Graph tags for social sharing."),
+    ]
+    details = {
+        "Title": title or "—",
+        "Meta description": description or "—",
+        "H1 headings": h1s or ["—"],
+        "Canonical": urljoin(response.url, canonical.get("href", "")) if canonical else "—",
+        "Page size": f"{len(response.content) / 1024:.1f} KB",
+    }
+    return findings, details
+
+
+def render() -> None:
+    url = st.text_input("Page URL", placeholder="https://example.com")
+    if not st.button("Run audit", type="primary", disabled=not url.strip()):
+        return
+    with st.spinner("Auditing…"):
+        try:
+            findings, details = audit(url)
+        except Exception as exc:
+            st.error(f"Could not audit page: {exc}")
+            return
+
+    passed = sum(ok for ok, _, _ in findings)
+    st.metric("Score", f"{round(passed / len(findings) * 100)} / 100", f"{passed} of {len(findings)} checks passed", delta_color="off")
+    for ok, label, message in findings:
+        st.markdown(f"{'✅' if ok else '⚠️'} **{label}** — {message}")
+    with st.expander("Extracted details"):
+        st.json(details)

mini_toolkit/tools/signature.py

@@ -0,0 +1,72 @@
+import base64
+import html
+
+import streamlit as st
+
+TEMPLATES = ["Classic", "Modern", "Minimal"]
+
+
+def generate_signature_html(name, title, company, phone, email, website, template="Classic", logo_base64=None, logo_mime="image/png"):
+    """Return email-client-friendly HTML (inline styles, tables) for a signature."""
+    if website and not website.startswith(("http://", "https://")):
+        website = "https://" + website
+    name, title, company, phone, email, website = map(html.escape, (name, title, company, phone, email, website))
+    role = " · ".join(part for part in (title, company) if part)
+    logo = (
+        f'<img src="data:{logo_mime};base64,{logo_base64}" alt="{company or "Logo"}" '
+        f'style="max-width:120px;height:auto;margin-bottom:10px;display:block;">' if logo_base64 else ""
+    )
+    email_link = f'<a href="mailto:{email}" style="color:#2563EB;text-decoration:none;">{email}</a>' if email else ""
+    web_link = f'<a href="{website}" style="color:#2563EB;text-decoration:none;">{website.split("://", 1)[-1]}</a>' if website else ""
+
+    if template == "Modern":
+        contact = "".join(
+            f'<p style="margin:2px 0;"><strong>{label}:</strong> {value}</p>'
+            for label, value in (("Phone", phone), ("Email", email_link), ("Web", web_link)) if value
+        )
+        return f"""<table cellpadding="0" cellspacing="0" style="font-family:Helvetica,Arial,sans-serif;color:#374151;border-collapse:collapse;">
+  <tr>
+    <td style="padding-right:16px;border-right:2px solid #2563EB;vertical-align:top;">
+      {logo}<p style="margin:0;font-size:18px;font-weight:bold;color:#111827;">{name}</p>
+      <p style="margin:4px 0 0;font-size:14px;color:#6B7280;">{role}</p>
+    </td>
+    <td style="padding-left:16px;font-size:13px;line-height:1.6;vertical-align:top;">{contact}</td>
+  </tr>
+</table>"""
+
+    if template == "Minimal":
+        details = " | ".join(v for v in (email_link, web_link, phone) if v)
+        return f"""<div style="font-family:'Courier New',Courier,monospace;font-size:12px;line-height:1.6;color:#4B5563;">
+  {logo}<strong>{name}</strong>{f" // {role}" if role else ""}<br>{details}
+</div>"""
+
+    contact = " | ".join(v for v in (f"<strong>P:</strong> {phone}" if phone else "", f"<strong>E:</strong> {email_link}" if email else "") if v)
+    return f"""<div style="font-family:Arial,sans-serif;line-height:1.5;color:#333333;font-size:14px;border-top:1px solid #E5E7EB;padding-top:10px;">
+  {logo}<p style="margin:0;"><strong style="font-size:16px;color:#2563EB;">{name}</strong></p>
+  <p style="margin:0;color:#6B7280;">{role}</p>
+  <p style="margin:8px 0 0;color:#6B7280;">{contact}</p>
+  {f'<p style="margin:0;color:#6B7280;"><strong>W:</strong> {web_link}</p>' if website else ""}
+</div>"""
+
+
+def render() -> None:
+    template = st.radio("Template", TEMPLATES, horizontal=True)
+    left, right = st.columns(2)
+    name = left.text_input("Full name", "Jane Doe")
+    title = left.text_input("Job title", "Product Designer")
+    company = left.text_input("Company", "Acme Inc.")
+    phone = right.text_input("Phone", "+1 555 010 0100")
+    email = right.text_input("Email", "jane@acme.com")
+    website = right.text_input("Website", "acme.com")
+    logo_file = st.file_uploader("Logo (optional)", type=["png", "jpg", "jpeg"])
+
+    logo_b64 = base64.b64encode(logo_file.getvalue()).decode() if logo_file else None
+    logo_mime = logo_file.type if logo_file else "image/png"
+    signature = generate_signature_html(name, title, company, phone, email, website, template, logo_b64, logo_mime)
+
+    light, dark, code = st.tabs(["Light preview", "Dark preview", "HTML"])
+    light.markdown(f"<div class='signature-preview light'>{signature}</div>", unsafe_allow_html=True)
+    dark.markdown(f"<div class='signature-preview dark'>{signature}</div>", unsafe_allow_html=True)
+    with code:
+        st.code(signature, language="html")
+        st.download_button("Download .html", signature, "email_signature.html", "text/html")

mini_toolkit/tools/ssl_checker.py

@@ -0,0 +1,68 @@
+import socket
+import ssl
+from datetime import datetime, timezone
+from urllib.parse import urlparse
+
+import streamlit as st
+
+from core.net import ensure_public_url
+
+
+def inspect_certificate(url: str) -> dict:
+    url = ensure_public_url(url)
+    parsed = urlparse(url)
+    host, port = parsed.hostname, parsed.port or 443
+    context = ssl.create_default_context()
+    with socket.create_connection((host, port), timeout=10) as sock:
+        with context.wrap_socket(sock, server_hostname=host) as tls:
+            cert = tls.getpeercert()
+            version = tls.version()
+
+    def name(field):
+        return dict(item[0] for item in cert.get(field, ())).get("commonName") or dict(
+            item[0] for item in cert.get(field, ())).get("organizationName", "—")
+
+    expires = datetime.strptime(cert["notAfter"], "%b %d %H:%M:%S %Y %Z").replace(tzinfo=timezone.utc)
+    issued = datetime.strptime(cert["notBefore"], "%b %d %H:%M:%S %Y %Z").replace(tzinfo=timezone.utc)
+    return {
+        "host": host,
+        "subject": name("subject"),
+        "issuer": name("issuer"),
+        "issued": issued,
+        "expires": expires,
+        "days_left": (expires - datetime.now(timezone.utc)).days,
+        "protocol": version,
+        "sans": [value for kind, value in cert.get("subjectAltName", ()) if kind == "DNS"],
+    }
+
+
+def render() -> None:
+    url = st.text_input("Domain or URL", placeholder="example.com")
+    if not st.button("Check certificate", type="primary", disabled=not url.strip()):
+        return
+    with st.spinner("Connecting…"):
+        try:
+            info = inspect_certificate(url)
+        except ssl.SSLCertVerificationError as exc:
+            st.error(f"Certificate is **not valid**: {exc.verify_message}")
+            return
+        except Exception as exc:
+            st.error(f"Could not check certificate: {exc}")
+            return
+
+    days = info["days_left"]
+    if days < 0:
+        st.error(f"Certificate expired {-days} days ago.")
+    elif days < 14:
+        st.warning(f"Valid, but expires in {days} days.")
+    else:
+        st.success(f"Valid certificate — {days} days remaining.")
+
+    cols = st.columns(3)
+    cols[0].metric("Expires", info["expires"].strftime("%d %b %Y"))
+    cols[1].metric("Issuer", info["issuer"])
+    cols[2].metric("Protocol", info["protocol"])
+    st.markdown(f"**Subject:** {info['subject']}  \n**Issued:** {info['issued']:%d %b %Y}")
+    if info["sans"]:
+        with st.expander(f"Covered domains ({len(info['sans'])})"):
+            st.write(", ".join(info["sans"]))

mini_toolkit/tools/text_to_speech.py

@@ -0,0 +1,34 @@
+import io
+
+import streamlit as st
+
+from core.ui import missing_dependency
+
+LANGUAGES = {
+    "English": "en", "Bengali": "bn", "Hindi": "hi", "Spanish": "es", "French": "fr",
+    "German": "de", "Arabic": "ar", "Chinese (Mandarin)": "zh-CN", "Japanese": "ja", "Portuguese": "pt",
+}
+
+
+def render() -> None:
+    try:
+        from gtts import gTTS
+    except ImportError:
+        missing_dependency("gTTS")
+        return
+
+    text = st.text_area("Text", height=180, placeholder="Type the text you want spoken…", max_chars=5000)
+    left, right = st.columns(2)
+    language = left.selectbox("Language", list(LANGUAGES))
+    slow = right.checkbox("Slow speech")
+
+    if st.button("Generate audio", type="primary", disabled=not text.strip()):
+        with st.spinner("Generating audio…"):
+            try:
+                buf = io.BytesIO()
+                gTTS(text=text, lang=LANGUAGES[language], slow=slow).write_to_fp(buf)
+            except Exception as exc:
+                st.error(f"Could not generate audio: {exc}")
+                return
+        st.audio(buf.getvalue(), format="audio/mp3")
+        st.download_button("Download MP3", buf.getvalue(), "speech.mp3", "audio/mpeg")

mini_toolkit/tools/text_utilities.py

@@ -0,0 +1,36 @@
+import re
+
+import streamlit as st
+
+TRANSFORMS = {
+    "None": lambda t: t,
+    "UPPERCASE": str.upper,
+    "lowercase": str.lower,
+    "Title Case": str.title,
+    "Sentence case": lambda t: re.sub(r"(^\s*|[.!?]\s+)([a-z])", lambda m: m.group(1) + m.group(2).upper(), t.lower()),
+    "snake_case": lambda t: re.sub(r"\W+", "_", t.strip()).strip("_").lower(),
+    "kebab-case": lambda t: re.sub(r"\W+", "-", t.strip()).strip("-").lower(),
+    "Remove extra spaces": lambda t: re.sub(r"[ \t]+", " ", re.sub(r"\n{3,}", "\n\n", t)).strip(),
+    "Remove line breaks": lambda t: " ".join(t.split()),
+}
+
+
+def stats(text: str) -> dict:
+    words = re.findall(r"\b\w+\b", text)
+    return {
+        "Characters": len(text),
+        "Words": len(words),
+        "Sentences": len(re.findall(r"[^.!?]+[.!?]", text)) or (1 if text.strip() else 0),
+        "Reading time": f"{max(1, round(len(words) / 200))} min" if words else "0 min",
+    }
+
+
+def render() -> None:
+    text = st.text_area("Your text", height=200, placeholder="Paste or type text here…")
+    for col, (label, value) in zip(st.columns(4), stats(text).items()):
+        col.metric(label, value)
+
+    transform = st.selectbox("Transform", list(TRANSFORMS))
+    if text and transform != "None":
+        st.caption("Result — use the copy icon in the top-right corner.")
+        st.code(TRANSFORMS[transform](text), language=None, wrap_lines=True)