Update app.py

app.py

@@ -5,7 +5,6 @@ import glob
 import textwrap
 from datetime import datetime
 from pathlib import Path
-from contextlib import redirect_stdout
 
 import streamlit as st
 import pandas as pd
@@ -16,98 +15,98 @@ from reportlab.lib.utils import ImageReader
 import mistune
 from gtts import gTTS
 
-# --- Core Utility Functions ---
+# --- Helper Functions ---
 
-# 🪄 Now you see it, now you don't.
-def delete_asset(path: str):
-    if os.path.exists(path):
+# 🗑️ Deletes a specified file and reruns the app.
+def delete_asset(path):
+    """Safely deletes a file if it exists and reruns the Streamlit app."""
+    try:
         os.remove(path)
+    except OSError as e:
+        st.error(f"Error deleting file {path}: {e}")
     st.rerun()
 
-# 🕵️‍♂️ On the hunt for related files in the digital jungle.
-def get_project_files(pattern: str = "*_*.*") -> dict:
-    projects = {}
-    for f in glob.glob(pattern):
-        stem = Path(f).stem
-        project_name = '_'.join(stem.split('_')[:-1])
-        if project_name not in projects:
-            projects[project_name] = {'md': [], 'images': []}
-        
-        ext = Path(f).suffix.lower()
-        if ext == '.md':
-            projects[project_name]['md'].append(f)
-        elif ext in ['.png', '.jpg', '.jpeg']:
-            projects[project_name]['images'].append(f)
-    return projects
-
-# ✨ Turning markdown into its simple, unadorned soul.
-def md_to_plain_text(md_text: str) -> str:
-    if not md_text:
-        return ""
-    html = mistune.html(md_text)
-    return re.sub(r'<[^>]+>', '', html).strip()
-
-# --- PDF & Audio Generation ---
-
-# 🎙️ Lending a golden voice to your silent words.
-def generate_audio(text: str, filename_stem: str, lang: str, slow: bool) -> str | None:
-    if not text:
-        st.warning("No text provided to generate audio.")
-        return None
-    
-    voice_file = f"{filename_stem}.mp3"
+# 📥 Gets text input from either a file upload or a text area.
+def get_text_input(file_uploader_label, accepted_types, text_area_label):
+    """
+    Provides UI for uploading a text file or entering text manually.
+    Returns the text content and a filename stem.
+    """
+    md_text = ""
+    stem = datetime.now().strftime('%Y%m%d_%H%M%S')
+
+    uploaded_file = st.file_uploader(file_uploader_label, type=accepted_types)
+    if uploaded_file:
+        md_text = uploaded_file.getvalue().decode("utf-8")
+        stem = Path(uploaded_file.name).stem
+    else:
+        md_text = st.text_area(text_area_label, height=200)
+
+    # Convert markdown to plain text for processing
+    renderer = mistune.HTMLRenderer()
+    markdown = mistune.create_markdown(renderer=renderer)
+    html = markdown(md_text or "")
+    plain_text = re.sub(r'<[^>]+>', '', html)
+
+    return plain_text, stem
+
+# 🗣️ Generates an MP3 voice file from text using gTTS.
+def generate_voice_file(text, lang, is_slow, filename):
+    """
+    Creates an MP3 from text, saves it, and provides it for playback and download.
+    """
+    if not text.strip():
+        st.warning("No text to generate voice from.")
+        return
+
+    voice_file_path = f"{filename}.mp3"
     try:
-        tts = gTTS(text=text, lang=lang, slow=slow)
-        tts.save(voice_file)
-        return voice_file
+        tts = gTTS(text=text, lang=lang, slow=is_slow)
+        tts.save(voice_file_path)
+        st.audio(voice_file_path)
+        with open(voice_file_path, 'rb') as fp:
+            st.download_button("📥 Download MP3", data=fp, file_name=voice_file_path, mime="audio/mpeg")
     except Exception as e:
         st.error(f"Failed to generate audio: {e}")
-        return None
 
-# ✍️ Weaving words into PDF poetry.
-def render_pdf_text(c: canvas.Canvas, text: str, settings: dict):
+# 📄 Creates a PDF document from text and images.
+def generate_pdf(text_content, images, pdf_params):
+    """
+    Generates a PDF buffer from text and a list of images based on specified parameters.
+    """
+    buf = io.BytesIO()
+    c = canvas.Canvas(buf)
     page_w, page_h = letter
     margin = 40
     gutter = 20
-    col_w = (page_w - 2 * margin - (settings['columns'] - 1) * gutter) / settings['columns']
-    
-    c.setFont(settings['font_family'], settings['font_size'])
-    line_height = settings['font_size'] * 1.2
-    wrap_width = int(col_w / (settings['font_size'] * 0.6))
+    col_w = (page_w - 2 * margin - (pdf_params['columns'] - 1) * gutter) / pdf_params['columns']
+
+    c.setFont(pdf_params['font_family'], pdf_params['font_size'])
+    line_height = pdf_params['font_size'] * 1.2
+    wrap_width = int(col_w / (pdf_params['font_size'] * 0.6))
 
     y = page_h - margin
-    col = 0
-    x = margin
-    
-    for paragraph in text.split("\n"):
-        wrapped_lines = textwrap.wrap(paragraph, wrap_width, replace_whitespace=False, drop_whitespace=False)
-        if not wrapped_lines: 
-            y -= line_height
-            if y < margin:
-                col, x, y = new_pdf_page_or_column(c, settings, col, margin, col_w, gutter, page_h)
-        
+    col_idx = 0
+
+    # --- Render Text ---
+    for paragraph in text_content.split("\n"):
+        wrapped_lines = textwrap.wrap(paragraph, wrap_width) if paragraph.strip() else [""]
         for line in wrapped_lines:
             if y < margin:
-                col, x, y = new_pdf_page_or_column(c, settings, col, margin, col_w, gutter, page_h)
-
+                col_idx += 1
+                if col_idx >= pdf_params['columns']:
+                    c.showPage()
+                    c.setFont(pdf_params['font_family'], pdf_params['font_size'])
+                    col_idx = 0
+                y = page_h - margin
+            
+            x = margin + col_idx * (col_w + gutter)
             c.drawString(x, y, line)
             y -= line_height
+        y -= line_height # Add extra space for paragraph breaks
 
-# 📄 Time to turn the page, or at least scoot over.
-def new_pdf_page_or_column(c, settings, col, margin, col_w, gutter, page_h):
-    col += 1
-    if col >= settings['columns']:
-        c.showPage()
-        c.setFont(settings['font_family'], settings['font_size'])
-        col = 0
-    
-    x = margin + col * (col_w + gutter)
-    y = page_h - margin
-    return col, x, y
-
-# 🖼️ Arranging your pixels perfectly on the page.
-def render_pdf_images(c: canvas.Canvas, image_files: list):
-    for img_file in image_files:
+    # --- Render Images ---
+    for img_file in images:
         try:
             img = Image.open(img_file)
             w, h = img.size
@@ -118,254 +117,149 @@ def render_pdf_images(c: canvas.Canvas, image_files: list):
             st.warning(f"Could not process image {img_file.name}: {e}")
             continue
 
-# 📜 The grand finale: text and images join forces in a PDF.
-def generate_pdf_from_content(text: str, images: list, settings: dict, filename_stem: str) -> bytes:
-    buf = io.BytesIO()
-    c = canvas.Canvas(buf, pagesize=letter)
-    
-    if text:
-        render_pdf_text(c, text, settings)
-    
-    if images:
-        render_pdf_images(c, images)
-        
     c.save()
     buf.seek(0)
-    return buf.getvalue()
-
-# --- Streamlit UI Components ---
-
-# 🎛️ Organizing the mission control for your creative genius.
-def setup_sidebar(projects: dict):
-    st.sidebar.header("🎨 PDF Style Settings")
-    settings = {
-        'columns': st.sidebar.slider("Text columns", 1, 3, 1),
-        'font_family': st.sidebar.selectbox("Font Family", ["Helvetica", "Times-Roman", "Courier"]),
-        'font_size': st.sidebar.slider("Font Size", 6, 24, 12)
-    }
-    
-    st.sidebar.header("📂 Project Files")
-    st.sidebar.caption("Files matching the `Name_Date` pattern.")
-    if not projects:
-        st.sidebar.info("No projects found. Upload files with a `_` in the name.")
-    else:
-        sorted_projects = sorted(projects.items())
-        for name, files in sorted_projects:
-            with st.sidebar.expander(f"Project: {name}"):
-                if files['md']:
-                    st.write("📄 " + ", ".join(Path(f).name for f in files['md']))
-                if files['images']:
-                    st.write("🖼️ " + ", ".join(Path(f).name for f in files['images']))
-
-    return settings
-
-# 🏆 Putting your magnificent creations on display.
-def display_local_assets():
+    return buf
+
+# 🗂️ Displays a list of generated assets with download/delete options.
+def show_asset_manager():
+    """Scans for local files and displays them with management controls."""
     st.markdown("---")
     st.subheader("📂 Available Assets")
-    assets = sorted(glob.glob("*.pdf") + glob.glob("*.mp3"))
+    assets = sorted(glob.glob("*.*"))
     if not assets:
-        st.info("No PDFs or MP3s generated yet.")
+        st.info("No assets generated yet.")
         return
-        
-    for asset_path in assets:
-        ext = Path(asset_path).suffix.lower()
-        cols = st.columns([4, 2, 1])
-        cols[0].write(f"`{asset_path}`")
-        
-        with open(asset_path, 'rb') as f:
-            file_bytes = f.read()
-
-        if ext == '.pdf':
-            cols[1].download_button("⬇️ Download PDF", data=file_bytes, file_name=asset_path, mime="application/pdf")
-        elif ext == '.mp3':
-            cols[1].audio(file_bytes, format='audio/mpeg')
-
-        cols[2].button("🗑️ Delete", key=f"del_{asset_path}", on_click=delete_asset, args=(asset_path,))
-
-# 🎭 The main stage for our PDF and Voice show.
-def pdf_composer_tab(projects: dict):
-    st.header("📄 PDF Composer & Voice Generator 🚀")
-    
-    col1, col2 = st.columns(2)
-    with col1:
-        input_method = st.radio(
-            "Choose your content source:",
-            ["Select an existing project", "Upload new files or paste text"],
-            horizontal=True,
-            label_visibility="collapsed"
-        )
-    
-    md_text = ""
-    selected_images = []
-    filename_stem = datetime.now().strftime('%Y%m%d_%H%M%S')
-
-    if input_method == "Select an existing project" and projects:
-        sorted_project_names = sorted(projects.keys())
-        chosen_project = st.selectbox("Select Project", sorted_project_names)
-        
-        md_files = projects[chosen_project]['md']
-        if md_files:
-            md_path = md_files[0]
-            filename_stem = Path(md_path).stem
-            with open(md_path, 'r', encoding='utf-8') as f:
-                md_text = f.read()
-            st.text_area("Markdown Content", value=md_text, height=250, key="md_from_project")
-        
-        image_files = projects[chosen_project]['images']
-        if image_files:
-            st.info(f"Found {len(image_files)} related image(s):")
-            for img in image_files:
-                st.image(img, width=150, caption=Path(img).name)
-                with open(img, 'rb') as f:
-                    bytes_io = io.BytesIO(f.read())
-                    bytes_io.name = Path(img).name
-                    selected_images.append(bytes_io)
-
-    else:
-        st.info("Upload a Markdown file, or just paste your text below.")
-        uploaded_files = st.file_uploader(
-            "Upload Markdown (.md) and Image files (.png, .jpg)",
-            type=["md", "png", "jpg", "jpeg"],
-            accept_multiple_files=True
-        )
-        
-        md_from_upload = [f for f in uploaded_files if f.type == "text/markdown"]
-        images_from_upload = [f for f in uploaded_files if f.type != "text/markdown"]
-        
-        if md_from_upload:
-            md_file = md_from_upload[0]
-            md_text = md_file.getvalue().decode("utf-8")
-            filename_stem = Path(md_file.name).stem
-        
-        md_text = st.text_area("Markdown Text", value=md_text, height=250, key="md_from_paste")
-        selected_images.extend(images_from_upload)
 
-    if selected_images:
-        st.subheader("🖼️ Arrange Images")
-        st.caption("Drag rows to reorder the images for the PDF.")
-        df_imgs = pd.DataFrame([{"order": i + 1, "name": f.name, "preview": f} for i, f in enumerate(selected_images)])
+    for asset_path in assets:
+        ext = asset_path.split('.')[-1].lower()
+        cols = st.columns([3, 1, 1])
+        cols[0].write(asset_path)
         
-        edited_df = st.data_editor(
-            df_imgs,
-            column_config={"preview": st.column_config.ImageColumn("Preview")},
-            hide_index=True,
-            use_container_width=True,
-            num_rows="dynamic"
-        )
-        ordered_names = edited_df['name'].tolist()
-        selected_images.sort(key=lambda x: ordered_names.index(x.name))
+        try:
+            with open(asset_path, 'rb') as fp:
+                file_bytes = fp.read()
+            
+            if ext == 'pdf':
+                cols[1].download_button("📥", data=file_bytes, file_name=asset_path, mime="application/pdf", key=f"dl_{asset_path}")
+            elif ext == 'mp3':
+                cols[1].audio(file_bytes)
+        except Exception as e:
+            cols[1].error("Error reading file.")
 
-    plain_text = md_to_plain_text(md_text)
+        cols[2].button("🗑️", key=f"del_{asset_path}", on_click=delete_asset, args=(asset_path,))
 
-    st.markdown("---")
-    st.subheader("🎬 Generate Your Files")
-    
-    pdf_settings = setup_sidebar(projects)
-
-    pdf_col, voice_col = st.columns(2)
-
-    with pdf_col:
-        if st.button("🖋️ Generate PDF", use_container_width=True, type="primary"):
-            if not plain_text and not selected_images:
-                st.error("Cannot generate an empty PDF. Please add some text or images.")
-            else:
-                with st.spinner("Crafting your PDF..."):
-                    pdf_bytes = generate_pdf_from_content(plain_text, selected_images, pdf_settings, filename_stem)
-                    st.download_button(
-                        label="⬇️ Download PDF",
-                        data=pdf_bytes,
-                        file_name=f"{filename_stem}.pdf",
-                        mime="application/pdf",
-                        use_container_width=True
-                    )
-                    st.success("PDF is ready for download!")
-
-    with voice_col:
-        st.markdown("<h6>Voice Generation</h6>", unsafe_allow_html=True)
-        languages = {"English (US)": "en", "English (UK)": "en-gb", "Spanish": "es"}
-        voice_choice = st.selectbox("Voice Language", list(languages.keys()))
-        slow_speech = st.checkbox("Slow Speech")
-        
-        if st.button("🔊 Generate MP3", use_container_width=True):
-            with st.spinner("Converting text to speech..."):
-                audio_file = generate_audio(plain_text, filename_stem, languages[voice_choice], slow_speech)
-                if audio_file:
-                    st.success("MP3 generated!")
-                    with open(audio_file, 'rb') as mp3:
-                        st.download_button("📥 Download MP3", data=mp3, file_name=audio_file, mime="audio/mpeg", use_container_width=True)
-                    st.audio(audio_file)
-    
-    display_local_assets()
-
-# --- Code Interpreter Section ---
-
-# 👻 Catching code spirits in a bottle (or a buffer).
-def execute_code(code: str) -> tuple[str | None, str | None]:
-    buf = io.StringIO()
-    try:
-        with redirect_stdout(buf):
-            exec(code, {})
-        return buf.getvalue(), None
-    except Exception as e:
-        return None, str(e)
+# � Renders the entire UI and logic for the Python code interpreter.
+def render_code_interpreter():
+    """Sets up the UI and execution logic for the code interpreter tab."""
+    st.header("🧪 Python Code Executor & Demo")
 
-# 🐍 Finding the sneaky Python hidden in the markdown grass.
-def extract_python_code(md: str) -> list[str]:
-    return re.findall(r"```python\s*(.*?)```", md, re.DOTALL)
+    # --- Nested Helper Functions for this Tab ---
+    def extract_python_code(md_text):
+        return re.findall(r"```python\s*(.*?)```", md_text, re.DOTALL)
 
-# 🧪 A safe lab for your wild Python experiments.
-def code_interpreter_tab():
-    st.header("🐍 Python Code Executor")
-    st.info("Execute Python code snippets. Note: This runs within the Streamlit environment.")
+    def execute_code(code_str):
+        output_buffer = io.StringIO()
+        try:
+            with redirect_stdout(output_buffer):
+                exec(code_str, {})
+            return output_buffer.getvalue(), None
+        except Exception as e:
+            return None, str(e)
 
-    DEFAULT_CODE = 'import streamlit as st\n\nst.balloons()\nst.write("Hello from the code interpreter!")'
-    
+    # --- Main Logic for the Tab ---
+    DEFAULT_CODE = "import streamlit as st\n\nst.balloons()\nst.write('Hello, World!')"
     if 'code' not in st.session_state:
         st.session_state.code = DEFAULT_CODE
 
-    uploaded_file = st.file_uploader("Upload .py or .md file with Python code", type=['py', 'md'])
-    
+    uploaded_file = st.file_uploader("Upload .py or .md", type=['py', 'md'])
     if uploaded_file:
-        text = uploaded_file.getvalue().decode()
+        file_content = uploaded_file.getvalue().decode()
         if uploaded_file.type == 'text/markdown':
-            codes = extract_python_code(text)
+            codes = extract_python_code(file_content)
             st.session_state.code = codes[0] if codes else ''
         else:
-            st.session_state.code = text
-
-    st.session_state.code = st.text_area("Code Editor", value=st.session_state.code, height=300, key="code_editor")
+            st.session_state.code = file_content
+        st.code(st.session_state.code, language='python')
+    else:
+        st.session_state.code = st.text_area("💻 Code Editor", value=st.session_state.code, height=300)
 
-    run_col, clear_col = st.columns(2)
-    if run_col.button("▶️ Run Code", use_container_width=True, type="primary"):
-        output, error = execute_code(st.session_state.code)
-        if error:
-            st.error(f"Execution Failed:\n\n{error}")
+    c1, c2 = st.columns(2)
+    if c1.button("▶️ Run Code", use_container_width=True):
+        output, err = execute_code(st.session_state.code)
+        if err:
+            st.error(err)
         elif output:
-            st.subheader("Output")
-            st.code(output, language=None)
+            st.code(output, language='text')
         else:
-            st.success("✅ Executed successfully with no output.")
-            
-    if clear_col.button("🗑️ Clear Code", use_container_width=True):
+            st.success("Executed successfully with no output.")
+    if c2.button("🗑️ Clear Code", use_container_width=True):
         st.session_state.code = ''
         st.rerun()
 
 # --- Main App ---
-
-# 🎬 Lights, camera, action! Kicking off the whole show.
 def main():
+    """Main function to run the Streamlit application."""
     st.set_page_config(page_title="PDF & Code Interpreter", layout="wide", page_icon="🚀")
-    
-    project_files = get_project_files()
-    
+
     tab1, tab2 = st.tabs(["📄 PDF Composer", "🧪 Code Interpreter"])
-    
+
     with tab1:
-        pdf_composer_tab(project_files)
+        st.header("📄 PDF Composer & Voice Generator 🚀")
+
+        # --- Sidebar Controls ---
+        st.sidebar.title("PDF Settings")
+        pdf_params = {
+            'columns': st.sidebar.slider("Text columns", 1, 3, 1),
+            'font_family': st.sidebar.selectbox("Font", ["Helvetica", "Times-Roman", "Courier"]),
+            'font_size': st.sidebar.slider("Font size", 6, 24, 12),
+        }
+
+        # --- Main UI ---
+        plain_text, filename_stem = get_text_input(
+            "Upload Markdown (.md)", ["md"], "Or enter markdown text directly"
+        )
+
+        st.subheader("🗣️ Voice Generation")
+        languages = {"English (US)": "en", "English (UK)": "en-uk", "Spanish": "es"}
+        voice_choice = st.selectbox("Voice Language", list(languages.keys()))
+        slow_speech = st.checkbox("Slow Speech")
+
+        if st.button("🔊 Generate Voice MP3"):
+            generate_voice_file(plain_text, languages[voice_choice], slow_speech, filename_stem)
+
+        st.subheader("🖼️ Image Upload")
+        uploaded_images = st.file_uploader(
+            "Upload Images for PDF", type=["png", "jpg", "jpeg"], accept_multiple_files=True
+        )
         
+        ordered_images = []
+        if uploaded_images:
+            df_imgs = pd.DataFrame([{"name": f.name, "order": i} for i, f in enumerate(uploaded_images)])
+            edited_df = st.data_editor(df_imgs, use_container_width=True, key="img_order_editor")
+            
+            # Create a map for quick lookup
+            image_map = {f.name: f for f in uploaded_images}
+            
+            # Sort and append images based on the edited order
+            for _, row in edited_df.sort_values("order").iterrows():
+                if row['name'] in image_map:
+                    ordered_images.append(image_map[row['name']])
+
+        st.subheader("🖋️ PDF Generation")
+        if st.button("Generate PDF with Markdown & Images"):
+            pdf_buffer = generate_pdf(plain_text, ordered_images, pdf_params)
+            st.download_button(
+                "⬇️ Download PDF",
+                data=pdf_buffer,
+                file_name=f"{filename_stem}.pdf",
+                mime="application/pdf"
+            )
+        
+        show_asset_manager()
+
     with tab2:
-        code_interpreter_tab()
+        render_code_interpreter()
 
 if __name__ == "__main__":
-    main()
+    main()