Update app.backup06102025.py

app.backup06102025.py

@@ -15,189 +15,251 @@ from reportlab.lib.utils import ImageReader
 import mistune
 from gtts import gTTS
 
-# Page config
-st.set_page_config(page_title="PDF & Code Interpreter", layout="wide", page_icon="🚀")
+# --- Helper Functions ---
 
+# 🗑️ 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:
-        pass
+    except OSError as e:
+        st.error(f"Error deleting file {path}: {e}")
     st.rerun()
 
-# Tabs setup
-tab1, tab2 = st.tabs(["📄 PDF Composer", "🧪 Code Interpreter"])
+# 📥 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')
 
-with tab1:
-    st.header("📄 PDF Composer & Voice Generator 🚀")
-
-    # Sidebar PDF text settings
-    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)
-
-    # Markdown input
-    md_file = st.file_uploader("Upload Markdown (.md)", type=["md"])
-    if md_file:
-        md_text = md_file.getvalue().decode("utf-8")
-        stem = Path(md_file.name).stem
+    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("Or enter markdown text directly", height=200)
-        stem = datetime.now().strftime('%Y%m%d_%H%M%S')
+        md_text = st.text_area(text_area_label, height=200)
 
-    # Convert Markdown to plain text
+    # 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)
 
-    # Voice settings
-    languages = {"English (US)": "en", "English (UK)": "en-uk", "Spanish": "es"}
-    voice_choice = st.selectbox("Voice Language", list(languages.keys()))
-    voice_lang = languages[voice_choice]
-    slow = st.checkbox("Slow Speech")
-
-    if st.button("🔊 Generate & Download Voice MP3 from Text"):
-        if plain_text.strip():
-            voice_file = f"{stem}.mp3"
-            tts = gTTS(text=plain_text, lang=voice_lang, slow=slow)
-            tts.save(voice_file)
-            st.audio(voice_file)
-            with open(voice_file, 'rb') as mp3:
-                st.download_button("📥 Download MP3", data=mp3, file_name=voice_file, mime="audio/mpeg")
-        else:
-            st.warning("No text to generate voice from.")
-
-    # Image uploads and ordering
-    imgs = st.file_uploader("Upload Images for PDF", type=["png", "jpg", "jpeg"], accept_multiple_files=True)
-    ordered_images = []
-    if imgs:
-        df_imgs = pd.DataFrame([{"name": f.name, "order": i} for i, f in enumerate(imgs)])
-        edited = st.data_editor(df_imgs, use_container_width=True)
-        for _, row in edited.sort_values("order").iterrows():
-            for f in imgs:
-                if f.name == row['name']:
-                    ordered_images.append(f)
-                    break
-
-    if st.button("🖋️ Generate PDF with Markdown & Images"):
-        buf = io.BytesIO()
-        c = canvas.Canvas(buf)
-
-        # Render text with columns
-        page_w, page_h = letter
-        margin = 40
-        gutter = 20
-        col_w = (page_w - 2*margin - (columns-1)*gutter) / columns
-        c.setFont(font_family, font_size)
-        line_height = font_size * 1.2
-        col = 0
-        x = margin
-        y = page_h - margin
-        wrap_width = int(col_w / (font_size * 0.6))
-
-        for paragraph in plain_text.split("\n"):
-            for line in textwrap.wrap(paragraph, wrap_width):
-                if y < margin:
-                    col += 1
-                    if col >= columns:
-                        c.showPage()
-                        c.setFont(font_family, font_size)
-                        col = 0
-                    x = margin + col*(col_w+gutter)
-                    y = page_h - margin
-                c.drawString(x, y, line)
-                y -= line_height
+    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=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}")
+
+# 📄 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 - (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_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_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
+
+    # --- Render Images ---
+    for img_file in images:
+        try:
+            img = Image.open(img_file)
+            w, h = img.size
+            c.showPage()
+            c.setPageSize((w, h))
+            c.drawImage(ImageReader(img), 0, 0, w, h, preserveAspectRatio=True, mask='auto')
+        except Exception as e:
+            st.warning(f"Could not process image {img_file.name}: {e}")
+            continue
 
-        # Autosize pages to each image
-        for img_f in ordered_images:
-            try:
-                img = Image.open(img_f)
-                w, h = img.size
-                c.showPage()
-                c.setPageSize((w, h))
-                c.drawImage(ImageReader(img), 0, 0, w, h, preserveAspectRatio=True, mask='auto')
-            except:
-                continue
-
-        c.save()
-        buf.seek(0)
-        pdf_name = f"{stem}.pdf"
-        st.download_button("⬇️ Download PDF", data=buf, file_name=pdf_name, mime="application/pdf")
+    c.save()
+    buf.seek(0)
+    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("*.*"))
-    for a in assets:
-        ext = a.split('.')[-1].lower()
+    if not assets:
+        st.info("No assets generated yet.")
+        return
+
+    for asset_path in assets:
+        ext = asset_path.split('.')[-1].lower()
         cols = st.columns([3, 1, 1])
-        cols[0].write(a)
-        if ext == 'pdf':
-            with open(a, 'rb') as fp:
-                cols[1].download_button("📥", data=fp, file_name=a, mime="application/pdf")
-        elif ext == 'mp3':
-            cols[1].audio(a)
-            with open(a, 'rb') as mp3:
-                cols[1].download_button("📥", data=mp3, file_name=a, mime="audio/mpeg")
-        cols[2].button("🗑️", key=f"del_{a}", on_click=delete_asset, args=(a,))
-
-with tab2:
+        cols[0].write(asset_path)
+        
+        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.")
+
+        cols[2].button("🗑️", key=f"del_{asset_path}", on_click=delete_asset, args=(asset_path,))
+
+# � 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")
-    import io, sys
-    from contextlib import redirect_stdout
-
-    DEFAULT_CODE = '''import streamlit as st
-import random
-
-st.title("📊 Demo App")
-st.markdown("Random number and color demo")
-
-col1, col2 = st.columns(2)
-with col1:
-    num = st.number_input("Number:", 1, 100, 10)
-    mul = st.slider("Multiplier:", 1, 10, 2)
-    if st.button("Calc"):
-        st.write(num * mul)
-with col2:
-    color = st.color_picker("Pick color","#ff0000")
-    st.markdown(f'<div style="background:{color};padding:10px;">Color</div>', unsafe_allow_html=True)
-'''  # noqa
-
-    def extract_python_code(md: str) -> list:
-        return re.findall(r"```python\s*(.*?)```", md, re.DOTALL)
-
-    def execute_code(code: str) -> tuple:
-        buf = io.StringIO(); local_vars = {}
+
+    # --- Nested Helper Functions for this Tab ---
+    def extract_python_code(md_text):
+        return re.findall(r"```python\s*(.*?)```", md_text, re.DOTALL)
+
+    def execute_code(code_str):
+        output_buffer = io.StringIO()
         try:
-            with redirect_stdout(buf): exec(code, {}, local_vars)
-            return buf.getvalue(), None
+            with redirect_stdout(output_buffer):
+                exec(code_str, {})
+            return output_buffer.getvalue(), None
         except Exception as e:
             return None, str(e)
 
-    up = st.file_uploader("Upload .py or .md", type=['py', 'md'])
+    # --- 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
-    if up:
-        text = up.getvalue().decode()
-        if up.type == 'text/markdown':
-            codes = extract_python_code(text)
+
+    uploaded_file = st.file_uploader("Upload .py or .md", type=['py', 'md'])
+    if uploaded_file:
+        file_content = uploaded_file.getvalue().decode()
+        if uploaded_file.type == 'text/markdown':
+            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 = 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)
 
-    c1, c2 = st.columns([1, 1])
-    if c1.button("▶️ Run Code"):
-        out, err = execute_code(st.session_state.code)
+    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 out:
-            st.code(out)
+        elif output:
+            st.code(output, language='text')
         else:
-            st.success("Executed with no output.")
-    if c2.button("🗑️ Clear Code"):
+            st.success("Executed successfully with no output.")
+    if c2.button("🗑️ Clear Code", use_container_width=True):
         st.session_state.code = ''
         st.rerun()
+
+# --- Main App ---
+def main():
+    """Main function to run the Streamlit application."""
+    st.set_page_config(page_title="PDF & Code Interpreter", layout="wide", page_icon="🚀")
+
+    tab1, tab2 = st.tabs(["📄 PDF Composer", "🧪 Code Interpreter"])
+
+    with tab1:
+        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:
+        render_code_interpreter()
+
+if __name__ == "__main__":
+    main()