Create app.py Backup 0622 SUN 0735

app.py Backup 0622 SUN 0735

@@ -0,0 +1,711 @@
+import io
+import os
+import re
+import glob
+import textwrap
+import streamlit as st
+import pandas as pd
+import mistune
+import fitz
+import edge_tts
+import asyncio
+import base64
+
+from datetime import datetime
+from pathlib import Path
+from PIL import Image
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter, A4, legal, A3, A5, LETTER, LEGAL
+from reportlab.lib.utils import ImageReader
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image as ReportLabImage
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib import colors
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+from urllib.parse import quote
+
+# 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()
+
+async def generate_audio(text, voice, filename):
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(filename)
+    return filename
+
+def clean_for_speech(text):
+    text = text.replace("#", "")
+    emoji_pattern = re.compile(
+        r"[\U0001F300-\U0001F5FF"
+        r"\U0001F600-\U0001F64F"
+        r"\U0001F680-\U0001F6FF"
+        r"\U0001F700-\U0001F77F"
+        r"\U0001F780-\U0001F7FF"
+        r"\U0001F800-\U0001F8FF"
+        r"\U0001F900-\U0001F9FF"
+        r"\U0001FA00-\U0001FA6F"
+        r"\U0001FA70-\U0001FAFF"
+        r"\u2600-\u26FF"
+        r"\u2700-\u27BF]+", flags=re.UNICODE)
+    return emoji_pattern.sub('', text)
+
+def detect_and_convert_links(text):
+    md_link_pattern = re.compile(r'\[(.*?)\]\((https?://[^\s\[\]()<>{}]+)\)')
+    text = md_link_pattern.sub(r'<a href="\2" color="blue">\1</a>', text)
+    url_pattern = re.compile(r'(?<!href=")(https?://[^\s<>{}]+)', re.IGNORECASE)
+    text = url_pattern.sub(r'<a href="\1" color="blue">\1</a>', text)
+    return text
+
+def apply_emoji_font(text, emoji_font):
+    tag_pattern = re.compile(r'(<[^>]+>)')
+    segments = tag_pattern.split(text)
+    result = []
+    emoji_pattern = re.compile(
+        r"([\U0001F300-\U0001F5FF"
+        r"\U0001F600-\U0001F64F"
+        r"\U0001F680-\U0001F6FF"
+        r"\U0001F700-\U0001F77F"
+        r"\U0001F780-\U0001F7FF"
+        r"\U0001F800-\U0001F8FF"
+        r"\U0001F900-\U0001F9FF"
+        r"\U0001FAD0-\U0001FAD9"
+        r"\U0001FA00-\U0001FA6F"
+        r"\U0001FA70-\U0001FAFF"
+        r"\u2600-\u26FF"
+        r"\u2700-\u27BF]+)"
+    )
+    def replace_emoji(match):
+        emoji = match.group(1)
+        return f'<font face="{emoji_font}">{emoji}</font>'
+    for segment in segments:
+        if tag_pattern.match(segment):
+            result.append(segment)
+        else:
+            parts = []
+            last_pos = 0
+            for match in emoji_pattern.finditer(segment):
+                start, end = match.span()
+                if last_pos < start:
+                    parts.append(f'<font face="DejaVuSans">{segment[last_pos:start]}</font>')
+                parts.append(replace_emoji(match))
+                last_pos = end
+            if last_pos < len(segment):
+                parts.append(f'<font face="DejaVuSans">{segment[last_pos:]}</font>')
+            result.append(''.join(parts))
+    return ''.join(result)
+
+def markdown_to_pdf_content(markdown_text, add_space_before_numbered, headings_to_fonts):
+    lines = markdown_text.strip().split('\n')
+    pdf_content = []
+    number_pattern = re.compile(r'^\d+(\.\d+)*\.\s')
+    heading_pattern = re.compile(r'^(#{1,4})\s+(.+)$')
+    first_numbered_seen = False
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        if headings_to_fonts and line.startswith('#'):
+            heading_match = heading_pattern.match(line)
+            if heading_match:
+                level = len(heading_match.group(1))
+                heading_text = heading_match.group(2).strip()
+                formatted_heading = f"<h{level}>{heading_text}</h{level}>"
+                pdf_content.append(formatted_heading)
+                continue
+        is_numbered_line = number_pattern.match(line) is not None
+        if add_space_before_numbered and is_numbered_line:
+            if first_numbered_seen and not line.startswith("1."):
+                pdf_content.append("")
+            if not first_numbered_seen:
+                first_numbered_seen = True
+        line = detect_and_convert_links(line)
+        line = re.sub(r'\*\*(.+?)\*\*', r'<b>\1</b>', line)
+        line = re.sub(r'\*([^*]+?)\*', r'<b>\1</b>', line)
+        pdf_content.append(line)
+    total_lines = len(pdf_content)
+    return pdf_content, total_lines
+
+def create_pdf(markdown_texts, image_files, base_font_size=14, num_columns=2, add_space_before_numbered=True, headings_to_fonts=True, doc_title="Combined Document", page_size=A4):
+    if not markdown_texts and not image_files:
+        return None
+    buffer = io.BytesIO()
+    
+    # Use the selected page size
+    if page_size == "A4":
+        page_dimensions = A4
+    elif page_size == "Letter":
+        page_dimensions = letter
+    elif page_size == "Legal":
+        page_dimensions = legal
+    elif page_size == "A3":
+        page_dimensions = A3
+    elif page_size == "A5":
+        page_dimensions = A5
+    else:
+        page_dimensions = A4  # Default fallback
+        
+    page_width = page_dimensions[0] * 2
+    page_height = page_dimensions[1]
+    
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=(page_width, page_height),
+        leftMargin=36,
+        rightMargin=36,
+        topMargin=36,
+        bottomMargin=36,
+        title=doc_title
+    )
+    styles = getSampleStyleSheet()
+    spacer_height = 10
+    try:
+        pdfmetrics.registerFont(TTFont("DejaVuSans", "DejaVuSans.ttf"))
+        pdfmetrics.registerFont(TTFont("NotoEmoji-Bold", "NotoEmoji-Bold.ttf"))
+    except Exception as e:
+        st.error(f"Font registration error: {e}")
+        return None
+    story = []
+    for markdown_text in markdown_texts:
+        pdf_content, total_lines = markdown_to_pdf_content(markdown_text, add_space_before_numbered, headings_to_fonts)
+        total_chars = sum(len(line) for line in pdf_content)
+        hierarchy_weight = sum(1.5 if line.startswith("<b>") else 1 for line in pdf_content)
+        longest_line_words = max(len(line.split()) for line in pdf_content) if pdf_content else 0
+        content_density = total_lines * hierarchy_weight + total_chars / 50
+        usable_height = page_height - 72 - spacer_height
+        usable_width = page_width - 72
+        avg_line_chars = total_chars / total_lines if total_lines > 0 else 50
+        col_width = usable_width / num_columns
+        min_font_size = 5
+        max_font_size = 16
+        lines_per_col = total_lines / num_columns if num_columns > 0 else total_lines
+        target_height_per_line = usable_height / lines_per_col if lines_per_col > 0 else usable_height
+        estimated_font_size = int(target_height_per_line / 1.5)
+        adjusted_font_size = max(min_font_size, min(max_font_size, estimated_font_size))
+        if avg_line_chars > col_width / adjusted_font_size * 10:
+            adjusted_font_size = int(col_width / (avg_line_chars / 10))
+            adjusted_font_size = max(min_font_size, adjusted_font_size)
+        if longest_line_words > 17 or lines_per_col > 20:
+            font_scale = min(17 / max(longest_line_words, 17), 60 / max(lines_per_col, 20))
+            adjusted_font_size = max(min_font_size, int(base_font_size * font_scale))
+        item_style = ParagraphStyle(
+            'ItemStyle', parent=styles['Normal'], fontName="DejaVuSans",
+            fontSize=adjusted_font_size, leading=adjusted_font_size * 1.15, spaceAfter=1,
+            linkUnderline=True
+        )
+        numbered_bold_style = ParagraphStyle(
+            'NumberedBoldStyle', parent=styles['Normal'], fontName="NotoEmoji-Bold",
+            fontSize=adjusted_font_size, leading=adjusted_font_size * 1.15, spaceAfter=1,
+            linkUnderline=True
+        )
+        section_style = ParagraphStyle(
+            'SectionStyle', parent=styles['Heading2'], fontName="DejaVuSans",
+            textColor=colors.darkblue, fontSize=adjusted_font_size * 1.1, leading=adjusted_font_size * 1.32, spaceAfter=2,
+            linkUnderline=True
+        )
+        columns = [[] for _ in range(num_columns)]
+        lines_per_column = total_lines / num_columns if num_columns > 0 else total_lines
+        current_line_count = 0
+        current_column = 0
+        number_pattern = re.compile(r'^\d+(\.\d+)*\.\s')
+        for item in pdf_content:
+            if current_line_count >= lines_per_column and current_column < num_columns - 1:
+                current_column += 1
+                current_line_count = 0
+            columns[current_column].append(item)
+            current_line_count += 1
+        column_cells = [[] for _ in range(num_columns)]
+        for col_idx, column in enumerate(columns):
+            for item in column:
+                if isinstance(item, str):
+                    heading_match = re.match(r'<h(\d)>(.*?)</h\1>', item) if headings_to_fonts else None
+                    if heading_match:
+                        level = int(heading_match.group(1))
+                        heading_text = heading_match.group(2)
+                        heading_style = ParagraphStyle(
+                            f'Heading{level}Style',
+                            parent=styles['Heading1'],
+                            fontName="DejaVuSans",
+                            textColor=colors.darkblue if level == 1 else (colors.black if level > 2 else colors.blue),
+                            fontSize=adjusted_font_size * (1.6 - (level-1)*0.15),
+                            leading=adjusted_font_size * (1.8 - (level-1)*0.15),
+                            spaceAfter=4 - (level-1),
+                            spaceBefore=6 - (level-1),
+                            linkUnderline=True
+                        )
+                        column_cells[col_idx].append(Paragraph(apply_emoji_font(heading_text, "NotoEmoji-Bold"), heading_style))
+                    elif item.startswith("<b>") and item.endswith("</b>"):
+                        content = item[3:-4].strip()
+                        if number_pattern.match(content):
+                            column_cells[col_idx].append(Paragraph(apply_emoji_font(content, "NotoEmoji-Bold"), numbered_bold_style))
+                        else:
+                            column_cells[col_idx].append(Paragraph(apply_emoji_font(content, "NotoEmoji-Bold"), section_style))
+                    else:
+                        column_cells[col_idx].append(Paragraph(apply_emoji_font(item, "NotoEmoji-Bold"), item_style))
+                else:
+                    column_cells[col_idx].append(Paragraph(apply_emoji_font(str(item), "NotoEmoji-Bold"), item_style))
+        max_cells = max(len(cells) for cells in column_cells) if column_cells else 0
+        for cells in column_cells:
+            cells.extend([Paragraph("", item_style)] * (max_cells - len(cells)))
+        table_data = list(zip(*column_cells)) if column_cells else [[]]
+        table = Table(table_data, colWidths=[col_width] * num_columns, hAlign='CENTER')
+        table.setStyle(TableStyle([
+            ('VALIGN', (0, 0), (-1, -1), 'TOP'),
+            ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+            ('BACKGROUND', (0, 0), (-1, -1), colors.white),
+            ('GRID', (0, 0), (-1, -1), 0, colors.white),
+            ('LINEAFTER', (0, 0), (num_columns-1, -1), 0.5, colors.grey),
+            ('LEFTPADDING', (0, 0), (-1, -1), 2),
+            ('RIGHTPADDING', (0, 0), (-1, -1), 2),
+            ('TOPPADDING', (0, 0), (-1, -1), 1),
+            ('BOTTOMPADDING', (0, 0), (-1, -1), 1),
+        ]))
+        story.append(Spacer(1, spacer_height))
+        story.append(table)
+        story.append(Spacer(1, spacer_height * 2))
+    for img_path in image_files:
+        try:
+            img = Image.open(img_path)
+            img_width, img_height = img.size
+            page_width_img, page_height_img = page_dimensions
+            scale = min((page_width_img - 40) / img_width, (page_height_img - 40) / img_height)
+            new_width = img_width * scale
+            new_height = img_height * scale
+            story.append(ReportLabImage(img_path, width=new_width, height=new_height))
+            story.append(Spacer(1, spacer_height))
+        except Exception as e:
+            st.warning(f"Could not process image {img_path}: {e}")
+            continue
+    doc.build(story)
+    buffer.seek(0)
+    return buffer.getvalue()
+
+def pdf_to_image(pdf_bytes):
+    if pdf_bytes is None:
+        return None
+    try:
+        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+        images = []
+        for page in doc:
+            pix = page.get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
+            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+            images.append(img)
+        doc.close()
+        return images
+    except Exception as e:
+        st.error(f"Failed to render PDF preview: {e}")
+        return None
+
+def get_video_html(video_path, width="100%"):
+    try:
+        video_url = f"data:video/mp4;base64,{base64.b64encode(open(video_path, 'rb').read()).decode()}"
+        return f'''
+        <video width="{width}" controls autoplay muted loop>
+            <source src="{video_url}" type="video/mp4">
+            Your browser does not support the video tag.
+        </video>
+        '''
+    except Exception as e:
+        st.warning(f"Could not load video {video_path}: {e}")
+        return ""
+
+def display_glossary_entity(k):
+    search_urls = {
+        "🚀🌌ArXiv": lambda k: f"https://arxiv.org/search/?query={quote(k)}&searchtype=all",
+        "📖": lambda k: f"https://en.wikipedia.org/wiki/{quote(k)}",
+        "🔍": lambda k: f"https://www.google.com/search?q={quote(k)}",
+        "🎥": lambda k: f"https://www.youtube.com/results?search_query={quote(k)}",
+    }
+    links_md = ' '.join([f"[{emoji}]({url(k)})" for emoji, url in search_urls.items()])
+    st.markdown(f"**{k}** <small>{links_md}</small>", unsafe_allow_html=True)
+
+# Tabs setup
+tab1, tab2 = st.tabs(["📄 PDF Composer", "🧪 Code Interpreter"])
+
+with tab1:
+    st.header("📄 PDF Composer & Voice Generator 🚀")
+    
+    # Sidebar PDF settings
+    with st.sidebar:
+        st.subheader("📄 PDF Settings")
+        columns = st.slider("Text columns", 1, 3, 2)
+        font_family = st.selectbox("Font", ["Helvetica", "Times-Roman", "Courier", "DejaVuSans"])
+        font_size = st.slider("Font size", 6, 24, 14)
+        
+        # Page size selection
+        page_size_options = {
+            "A4 (210 × 297 mm)": "A4",
+            "Letter (8.5 × 11 in)": "Letter", 
+            "Legal (8.5 × 14 in)": "Legal",
+            "A3 (297 × 420 mm)": "A3",
+            "A5 (148 × 210 mm)": "A5"
+        }
+        selected_page_size = st.selectbox(
+            "📏 Page Size", 
+            options=list(page_size_options.keys()),
+            index=0  # Default to A4
+        )
+        page_size = page_size_options[selected_page_size]
+    
+    # Multiple markdown file upload
+    md_files = st.file_uploader("Upload Markdown Files (.md)", type=["md"], accept_multiple_files=True)
+    markdown_texts = []
+    combined_text = ""
+    
+    if md_files:
+        st.subheader(f"📂 Uploaded Files ({len(md_files)})")
+        for i, md_file in enumerate(md_files):
+            md_text = md_file.getvalue().decode("utf-8")
+            markdown_texts.append(md_text)
+            combined_text += md_text + "\n\n"
+            
+            with st.expander(f"📄 {md_file.name}"):
+                st.markdown(md_text[:500] + "..." if len(md_text) > 500 else md_text)
+        
+        stem = f"combined_{len(md_files)}_files_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    else:
+        # Single text area for manual input
+        manual_text = st.text_area("Or enter markdown text directly", height=200)
+        if manual_text:
+            markdown_texts = [manual_text]
+            combined_text = manual_text
+        stem = datetime.now().strftime('%Y%m%d_%H%M%S')
+    
+    # Convert Markdown to plain text for voice generation
+    if combined_text:
+        renderer = mistune.HTMLRenderer()
+        markdown = mistune.create_markdown(renderer=renderer)
+        html = markdown(combined_text)
+        plain_text = re.sub(r'<[^>]+>', '', html)
+        
+        st.subheader("📊 Content Summary")
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Files", len(md_files) if md_files else 1)
+        with col2:
+            st.metric("Total Characters", len(combined_text))
+        with col3:
+            st.metric("Estimated Words", len(combined_text.split()))
+        with col4:
+            st.metric("Page Size", selected_page_size.split(" (")[0])
+    else:
+        plain_text = ""
+    
+    # Voice settings
+    st.subheader("🔊 Text-to-Speech Settings")
+    col1, col2 = st.columns(2)
+    with col1:
+        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")
+    
+    with col2:
+        VOICES = ["en-US-AriaNeural", "en-US-JennyNeural", "en-GB-SoniaNeural", "en-US-GuyNeural", "en-US-AnaNeural"]
+        selected_voice = st.selectbox("Select Voice for TTS", options=VOICES, index=0)
+    
+    if st.button("🔊 Generate & Download Voice MP3 from Text"):
+        if plain_text.strip():
+            voice_file = f"{stem}_{selected_voice}.mp3"
+            try:
+                with st.spinner("Generating audio..."):
+                    cleaned_text = clean_for_speech(plain_text)
+                    audio_file = asyncio.run(generate_audio(cleaned_text, selected_voice, voice_file))
+                st.success("Audio generated successfully!")
+                st.audio(audio_file)
+                with open(audio_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
+    st.subheader("🖼️ Image Management")
+    imgs = st.file_uploader("Upload Images for PDF", type=["png", "jpg", "jpeg"], accept_multiple_files=True)
+    ordered_images = []
+    if imgs:
+        st.write(f"📊 Uploaded {len(imgs)} images")
+        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")
+        for _, row in edited.sort_values("order").iterrows():
+            for f in imgs:
+                if f.name == row['name']:
+                    ordered_images.append(f)
+                    break
+    
+    # PDF Generation
+    st.subheader("📄 PDF Generation")
+    
+    if st.button("🖋️ Generate PDF with Markdown & Images", type="primary"):
+        if not markdown_texts and not ordered_images:
+            st.warning("Please provide some markdown text or upload images to generate a PDF.")
+        else:
+            with st.spinner(f"Generating PDF with {page_size} page size..."):
+                if markdown_texts and not ordered_images:
+                    # Use the enhanced create_pdf function
+                    pdf_bytes = create_pdf(
+                        markdown_texts=markdown_texts,
+                        image_files=[],
+                        base_font_size=font_size,
+                        num_columns=columns,
+                        add_space_before_numbered=True,
+                        headings_to_fonts=True,
+                        doc_title=f"Markdown_Document_{len(markdown_texts)}_files",
+                        page_size=page_size
+                    )
+                    
+                    if pdf_bytes:
+                        pdf_images = pdf_to_image(pdf_bytes)
+                        if pdf_images:
+                            st.subheader("Preview of Generated PDF")
+                            for i, img in enumerate(pdf_images):
+                                st.image(img, caption=f"Page {i+1}", use_container_width=True)
+                        
+                        pdf_name = f"{stem}.pdf"
+                        st.download_button("⬇️ Download PDF", data=pdf_bytes, file_name=pdf_name, mime="application/pdf")
+                    else:
+                        st.error("Failed to generate PDF from markdown.")
+                else:
+                    # Fallback to original simple PDF generation for mixed content
+                    buf = io.BytesIO()
+                    
+                    # Get page dimensions for the selected page size
+                    if page_size == "A4":
+                        page_dimensions = A4
+                    elif page_size == "Letter":
+                        page_dimensions = letter
+                    elif page_size == "Legal":
+                        page_dimensions = legal
+                    elif page_size == "A3":
+                        page_dimensions = A3
+                    elif page_size == "A5":
+                        page_dimensions = A5
+                    else:
+                        page_dimensions = A4
+                    
+                    c = canvas.Canvas(buf, pagesize=page_dimensions)
+                    
+                    if plain_text.strip():
+                        page_w, page_h = page_dimensions
+                        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
+                        avg_char_width = font_size * 0.6
+                        wrap_width = int(col_w / avg_char_width) if avg_char_width > 0 else 100
+                        for paragraph in plain_text.split("\n"):
+                            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
+                            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
+                    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=False)
+                        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.success(f"PDF generated successfully with {page_size} page size!")
+                    st.download_button("⬇️ Download PDF", data=buf, file_name=pdf_name, mime="application/pdf")
+    
+    st.markdown("---")
+    st.subheader("📂 Available Assets")
+    all_assets = glob.glob("*.*")
+    excluded_extensions = ['.py', '.ttf', '.txt']
+    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)
+        and a.lower().endswith(('.md', '.png', '.jpg', '.jpeg'))
+    ])
+    if 'selected_assets' not in st.session_state:
+        st.session_state.selected_assets = []
+    if not assets:
+        st.info("No available assets found.")
+    else:
+        for a in assets:
+            ext = a.split('.')[-1].lower()
+            cols = st.columns([1, 3, 1, 1])
+            with cols[0]:
+                is_selected = st.checkbox("", key=f"select_{a}", value=a in st.session_state.selected_assets)
+                if is_selected and a not in st.session_state.selected_assets:
+                    st.session_state.selected_assets.append(a)
+                elif not is_selected and a in st.session_state.selected_assets:
+                    st.session_state.selected_assets.remove(a)
+            cols[1].write(a)
+            try:
+                if ext == 'md':
+                    with open(a, 'r', encoding='utf-8') as f:
+                        cols[2].download_button("📥", data=f.read(), file_name=a, mime="text/markdown")
+                elif ext in ['png', 'jpg', 'jpeg']:
+                    with open(a, 'rb') as img_file:
+                        cols[2].download_button("⬇️", data=img_file, file_name=a, mime=f"image/{ext}")
+                cols[3].button("🗑️", key=f"del_{a}", on_click=delete_asset, args=(a,))
+            except Exception as e:
+                cols[3].error(f"Error handling file {a}: {e}")
+        if st.button("📑 Generate PDF from Selected Assets"):
+            if not st.session_state.selected_assets:
+                st.warning("Please select at least one asset to generate a PDF.")
+            else:
+                selected_markdown_texts = []
+                image_files = []
+                for a in st.session_state.selected_assets:
+                    ext = a.split('.')[-1].lower()
+                    if ext == 'md':
+                        with open(a, 'r', encoding='utf-8') as f:
+                            selected_markdown_texts.append(f.read())
+                    elif ext in ['png', 'jpg', 'jpeg']:
+                        image_files.append(a)
+                with st.spinner("Generating PDF from selected assets..."):
+                    pdf_bytes = create_pdf(
+                        markdown_texts=selected_markdown_texts,
+                        image_files=image_files,
+                        base_font_size=font_size,
+                        num_columns=columns,
+                        add_space_before_numbered=True,
+                        headings_to_fonts=True,
+                        doc_title="Combined_Selected_Assets",
+                        page_size=page_size
+                    )
+                    if pdf_bytes:
+                        pdf_images = pdf_to_image(pdf_bytes)
+                        if pdf_images:
+                            st.subheader("Preview of Generated PDF")
+                            for i, img in enumerate(pdf_images):
+                                st.image(img, caption=f"Page {i+1}", use_container_width=True)
+                        prefix = datetime.now().strftime("%Y%m%d_%H%M%S")
+                        st.download_button(
+                            label="💾 Download Combined PDF",
+                            data=pdf_bytes,
+                            file_name=f"{prefix}_combined.pdf",
+                            mime="application/pdf"
+                        )
+                    else:
+                        st.error("Failed to generate PDF.")
+    
+    st.markdown("---")
+    st.subheader("🖼 Image Gallery")
+    image_files = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.jpeg")
+    image_cols = st.slider("Gallery Columns 🖼", min_value=1, max_value=15, value=5, key="image_cols")
+    if image_files:
+        cols = st.columns(image_cols)
+        for idx, image_file in enumerate(image_files):
+            with cols[idx % image_cols]:
+                try:
+                    img = Image.open(image_file)
+                    st.image(img, caption=image_file, use_container_width=True)
+                    display_glossary_entity(os.path.splitext(image_file)[0])
+                except Exception as e:
+                    st.warning(f"Could not load image {image_file}: {e}")
+    else:
+        st.info("No images found in the current directory.")
+    
+    st.markdown("---")
+    st.subheader("🎥 Video Gallery")
+    video_files = glob.glob("*.mp4")
+    video_cols = st.slider("Gallery Columns 🎬", min_value=1, max_value=5, value=3, key="video_cols")
+    if video_files:
+        cols = st.columns(video_cols)
+        for idx, video_file in enumerate(video_files):
+            with cols[idx % video_cols]:
+                st.markdown(get_video_html(video_file, width="100%"), unsafe_allow_html=True)
+                display_glossary_entity(os.path.splitext(video_file)[0])
+    else:
+        st.info("No videos found in the current directory.")
+
+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)
+'''
+    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 = {}
+        try:
+            with redirect_stdout(buf):
+                exec(code, {}, local_vars)
+            return buf.getvalue(), None
+        except Exception as e:
+            return None, str(e)
+    up = st.file_uploader("Upload .py or .md", type=['py', 'md'])
+    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:
+                st.session_state.code = codes[0].strip()
+            else:
+                st.warning("No Python code block found in the markdown file.")
+                st.session_state.code = ''
+        else:
+            st.session_state.code = text.strip()
+        st.code(st.session_state.code, language='python')
+    else:
+        st.session_state.code = st.text_area("💻 Code Editor", value=st.session_state.code, height=400)
+    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()