Spaces:
Sleeping
Sleeping
| import io | |
| import os | |
| import re | |
| import glob | |
| import textwrap | |
| from datetime import datetime | |
| from pathlib import Path | |
| import streamlit as st | |
| import pandas as pd | |
| from PIL import Image | |
| from reportlab.pdfgen import canvas | |
| from reportlab.lib.pagesizes import letter | |
| 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="🚀") | |
| def delete_asset(path): | |
| try: | |
| os.remove(path) | |
| except Exception as e: | |
| st.error(f"Error deleting file: {e}") | |
| st.rerun() | |
| # Tabs setup | |
| tab1, tab2 = st.tabs(["📄 PDF Composer", "🧪 Code Interpreter"]) | |
| 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 | |
| else: | |
| md_text = st.text_area("Or enter markdown text directly", height=200) | |
| stem = datetime.now().strftime('%Y%m%d_%H%M%S') | |
| # Convert Markdown to plain text | |
| # Using mistune to parse markdown to HTML, then stripping HTML tags | |
| renderer = mistune.HTMLRenderer() | |
| markdown = mistune.create_markdown(renderer=renderer) | |
| html = markdown(md_text or "") | |
| plain_text = re.sub(r'<[^>]+>', '', html) # Strip HTML tags | |
| # 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" | |
| try: | |
| 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") | |
| except Exception as e: | |
| st.error(f"Error generating voice: {e}") | |
| 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: | |
| # Create a DataFrame for editing image order | |
| 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, num_rows="dynamic") # Use num_rows="dynamic" for better UI | |
| # Reconstruct the ordered list of file objects | |
| for _, row in edited.sort_values("order").iterrows(): | |
| for f in imgs: | |
| if f.name == row['name']: | |
| ordered_images.append(f) | |
| break # Found the file object, move to the next row | |
| if st.button("🖋️ Generate PDF with Markdown & Images"): | |
| if not plain_text.strip() and not ordered_images: | |
| st.warning("Please provide some text or upload images to generate a PDF.") | |
| else: | |
| buf = io.BytesIO() | |
| c = canvas.Canvas(buf) | |
| # Render text with columns if there is text | |
| if plain_text.strip(): | |
| 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 | |
| # Estimate wrap width based on font size and column width | |
| # This is an approximation and might need fine-tuning | |
| avg_char_width = font_size * 0.6 # Approximation | |
| wrap_width = int(col_w / avg_char_width) if avg_char_width > 0 else 100 # Prevent division by zero | |
| for paragraph in plain_text.split("\n"): | |
| # Handle empty lines by adding vertical space | |
| if not paragraph.strip(): | |
| y -= line_height | |
| 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 | |
| continue # Skip to next paragraph | |
| 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 | |
| y -= line_height # Add space between paragraphs | |
| # Autosize pages to each image | |
| for img_f in ordered_images: | |
| try: | |
| img = Image.open(img_f) | |
| w, h = img.size | |
| c.showPage() # Start a new page for each image | |
| # Set page size to image size | |
| c.setPageSize((w, h)) | |
| # Draw image filling the page | |
| c.drawImage(ImageReader(img), 0, 0, w, h, preserveAspectRatio=False) # Use False to fill page exactly | |
| except Exception as e: | |
| st.warning(f"Could not process image {img_f.name}: {e}") | |
| 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") | |
| st.markdown("---") | |
| st.subheader("📂 Available Assets") | |
| # Get all files and filter out unwanted ones | |
| all_assets = glob.glob("*.*") | |
| excluded_extensions = ['.py', '.ttf'] | |
| excluded_files = ['README.md', 'index.html'] | |
| assets = sorted([ | |
| a for a in all_assets | |
| if not (a.lower().endswith(tuple(excluded_extensions)) or a in excluded_files) | |
| ]) | |
| if not assets: | |
| st.info("No available assets found.") | |
| else: | |
| for a in assets: | |
| ext = a.split('.')[-1].lower() | |
| cols = st.columns([3, 1, 1]) | |
| cols[0].write(a) | |
| # Provide download/preview based on file type | |
| try: | |
| if ext == 'pdf': | |
| with open(a, 'rb') as fp: | |
| cols[1].download_button("📥", data=fp, file_name=a, mime="application/pdf") | |
| elif ext == 'mp3': | |
| # Streamlit can play audio directly from file path | |
| cols[1].audio(a) | |
| with open(a, 'rb') as mp3: | |
| cols[1].download_button("📥", data=mp3, file_name=a, mime="audio/mpeg") | |
| # Add more file types here if needed (e.g., images) | |
| elif ext in ['png', 'jpg', 'jpeg', 'gif']: | |
| # Can't preview image directly in this column, offer download | |
| with open(a, 'rb') as img_file: | |
| cols[1].download_button("⬇️", data=img_file, file_name=a, mime=f"image/{ext}") | |
| # Handle other file types - maybe just offer download | |
| else: | |
| with open(a, 'rb') as other_file: | |
| cols[1].download_button("⬇️", data=other_file, file_name=a) # Mime type is guessed by streamlit | |
| # Delete button | |
| cols[2].button("🗑️", key=f"del_{a}", on_click=delete_asset, args=(a,)) | |
| except Exception as e: | |
| cols[2].error(f"Error handling file {a}: {e}") | |
| with tab2: | |
| 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: | |
| # Find all blocks starting with ```python and ending with ``` | |
| return re.findall(r"```python\s*(.*?)```", md, re.DOTALL) | |
| def execute_code(code: str) -> tuple: | |
| buf = io.StringIO(); local_vars = {} | |
| # Redirect stdout to capture print statements | |
| try: | |
| with redirect_stdout(buf): | |
| # Use exec to run the code. locals() and globals() are needed. | |
| # Passing empty dicts might limit some functionalities but provides isolation. | |
| exec(code, {}, local_vars) | |
| return buf.getvalue(), None # Return captured output | |
| except Exception as e: | |
| return None, str(e) # Return error message | |
| up = st.file_uploader("Upload .py or .md", type=['py', 'md']) | |
| # Initialize session state for code if it doesn't exist | |
| 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) | |
| if codes: | |
| # Take the first python code block found | |
| st.session_state.code = codes[0].strip() | |
| else: | |
| st.warning("No Python code block found in the markdown file.") | |
| st.session_state.code = '' # Clear code if no block found | |
| else: # .py file | |
| st.session_state.code = text.strip() | |
| # Display the code after upload | |
| st.code(st.session_state.code, language='python') | |
| else: | |
| # Text area for code editing if no file is uploaded or after processing upload | |
| st.session_state.code = st.text_area("💻 Code Editor", value=st.session_state.code, height=400) # Increased height | |
| c1, c2 = st.columns([1, 1]) | |
| if c1.button("▶️ Run Code"): | |
| if st.session_state.code.strip(): | |
| out, err = execute_code(st.session_state.code) | |
| if err: | |
| st.error(f"Execution Error:\n{err}") | |
| elif out: | |
| st.subheader("Output:") | |
| st.code(out) | |
| else: | |
| st.success("Executed with no standard output.") | |
| else: | |
| st.warning("No code to run.") | |
| if c2.button("🗑️ Clear Code"): | |
| st.session_state.code = '' | |
| st.rerun() |