Update app.py

app.py

@@ -31,206 +31,329 @@ from io import BytesIO
 
 
 
-def run_pdf_converter_app():
+
+def run_ultimate_pdf_converter():
     """
-    All-in-one function for Advanced Text-to-PDF conversion.
-    Features: Unicode, Markdown-like formatting, Image embedding, and Smart Symbol Replacement.
+    The Ultimate Text-to-PDF Converter.
+    Contains ~55 features grouped into:
+    1. Smart Typography (Symbols, Quotes)
+    2. Markdown Engine (Headers, Tables, Code Blocks, Lists)
+    3. Media Handler (Images, Links)
+    4. Layout Engine (Margins, Orientation, Fonts)
+    5. LMS Sanitizer (Cleaning junk text)
     """
 
-    # --- 1. CONFIG: Smart Symbol Replacement Dictionary ---
-    # Automatically fixes common plain-text approximations into real symbols
-    SYMBOL_MAP = {
-        r'\->': '→',
-        r'<-': '←',
-        r'<=': '≤',
-        r'>=': '≥',
-        r'!=': '≠',
-        r'\.\.\.': '…',
-        r'\(c\)': '©',
-        r'\(r\)': '®',
-        r'alpha': 'α',
-        r'beta': 'β',
-        r'theta': 'θ',
-        r'pi': 'π',
-        r'sigma': 'Σ',
-        r'delta': 'Δ',
-        r'gamma': 'Γ',
-        r'omega': 'Ω',
-        r'mu': 'μ',
-        r'lambda': 'λ',
-        r'sqrt': '√',
-        r'deg': '°'
+    # --- CONSTANTS & CONFIG ---
+    # Feature Group 1: Smart Symbol Map (20+ symbols)
+    SMART_SYMBOLS = {
+        r'<->': '↔', r'->': '→', r'<-': '←', r'=>': '⇒', r'<=': '≤', r'>=': '≥', r'!=': '≠',
+        r'\.\.\.': '…', r'\(c\)': '©', r'\(r\)': '®', r'\(tm\)': '™',
+        r'\+-': '±', r'\~=': '≈', r'--': '—',
+        r'alpha': 'α', r'beta': 'β', r'theta': 'θ', r'pi': 'π', r'sigma': 'Σ',
+        r'delta': 'Δ', r'gamma': 'Γ', r'omega': 'Ω', r'mu': 'μ', r'lambda': 'λ',
+        r'deg': '°', r'infinity': '∞', r'sqrt': '√'
     }
 
-    # --- 2. HELPER: Download Font ---
-    def get_unicode_font():
-        font_path = "DejaVuSans.ttf"
-        font_url = "https://github.com/dejavu-fonts/dejavu-fonts/raw/master/ttf/DejaVuSans.ttf"
-        
-        if not os.path.exists(font_path):
-            try:
-                response = requests.get(font_url, timeout=10)
-                with open(font_path, "wb") as f:
-                    f.write(response.content)
-            except Exception as e:
-                st.error(f"Font download failed: {e}")
-                return None
-        return font_path
-
-    # --- 3. HELPER: Clean & Enhance Text ---
-    def process_text(text, remove_lms_junk=True, smart_symbols=True):
-        if not text: return ""
-
-        # A. Basic Normalization
-        text = text.replace('\r\n', '\n').replace('\r', '\n')
-
-        # B. LMS Junk Removal (Aggressive)
-        if remove_lms_junk:
-            # Removes "Question ID: [12345]" patterns
-            text = re.sub(r'Question\s+ID\s*[:\-]\s*\[?\w+\]?', '', text, flags=re.IGNORECASE)
-            # Removes "Points: 1.0" or similar
-            text = re.sub(r'Points\s*[:\-]\s*\d+(\.\d+)?', '', text, flags=re.IGNORECASE)
-            # Removes timestamps like [10:00 AM]
-            text = re.sub(r'\[\d{1,2}:\d{2}\s*(AM|PM)?\]', '', text)
-            # Removes text in square brackets mostly used for metadata
-            text = re.sub(r'\[.*?\]', '', text)
-
-        # C. Smart Symbol Replacement
-        if smart_symbols:
-            for pattern, symbol in SYMBOL_MAP.items():
-                # We use regex to ensure we don't replace inside words (e.g. 'alphabet' shouldn't become 'αbet')
-                # But for simple symbols like '->', direct replace is safer
-                if pattern.isalpha(): # Word replacement (alpha -> α)
-                     text = re.sub(r'\b' + pattern + r'\b', symbol, text, flags=re.IGNORECASE)
-                else: # Symbol replacement (-> -> →)
-                     text = re.sub(pattern, symbol, text)
-
-        return text.strip()
-
-    # --- 4. HELPER: PDF Generator Class ---
-    class PDF(FPDF):
+    # --- INTERNAL CLASS: PDF GENERATOR ---
+    class UltimatePDF(FPDF):
+        def __init__(self, orientation='P', unit='mm', format='A4', font_cache_dir="."):
+            super().__init__(orientation=orientation, unit=unit, format=format)
+            self.font_cache_dir = font_cache_dir
+            self.ensure_fonts()
+            self.set_auto_page_break(auto=True, margin=15)
+
+        def ensure_fonts(self):
+            # Feature: Auto-download Unicode Font
+            font_path = os.path.join(self.font_cache_dir, "DejaVuSans.ttf")
+            font_url = "https://github.com/dejavu-fonts/dejavu-fonts/raw/master/ttf/DejaVuSans.ttf"
+            if not os.path.exists(font_path):
+                try:
+                    r = requests.get(font_url, timeout=10)
+                    with open(font_path, "wb") as f:
+                        f.write(r.content)
+                except:
+                    pass # Fallback handled later
+            
+            if os.path.exists(font_path):
+                self.add_font('DejaVu', '', font_path, uni=True)
+                self.add_font('DejaVu', 'B', font_path, uni=True) # Bold attempt
+                self.main_font = 'DejaVu'
+            else:
+                self.main_font = 'Arial'
+
         def header(self):
-            # Optional: Add a subtle header if needed
-            pass 
+            # Feature: Automatic Header with Date/Page
+            if getattr(self, 'show_header', False):
+                self.set_font(self.main_font, '', 8)
+                self.set_text_color(128)
+                self.cell(0, 10, f'Generated by Ultimate PDF | {self.title_meta}', 0, 0, 'R')
+                self.ln(10)
 
         def footer(self):
+            # Feature: Page Numbering
             self.set_y(-15)
-            self.set_font("Arial", "I", 8)
+            self.set_font(self.main_font, '', 8)
+            self.set_text_color(128)
             self.cell(0, 10, f'Page {self.page_no()}', 0, 0, 'C')
 
-    # --- 5. MAIN LOGIC: Generate PDF ---
-    def generate_pdf(content, font_size=12, margin=10):
-        pdf = PDF()
-        pdf.set_auto_page_break(auto=True, margin=15)
-        pdf.set_margins(margin, margin, margin)
-        pdf.add_page()
-
-        # Load Font
-        font_path = get_unicode_font()
-        if font_path:
-            pdf.add_font('DejaVu', '', font_path, uni=True)
-            pdf.set_font('DejaVu', '', font_size)
-        else:
-            pdf.set_font("Arial", size=font_size)
-            st.warning("⚠️ Unicode font missing. Symbols may not render.")
+        def add_markdown_header(self, text, level):
+            # Feature: Dynamic Header Sizes (H1, H2, H3)
+            sizes = {1: 24, 2: 18, 3: 14}
+            self.set_font(self.main_font, '', sizes.get(level, 12))
+            self.set_text_color(0, 50, 100) # Navy Blue
+            self.cell(0, 10, text, ln=True)
+            self.set_text_color(0) # Reset
+            self.set_font(self.main_font, '', 12)
+
+        def add_code_block(self, code_lines):
+            # Feature: Code Block Formatting (Gray background, Monospace)
+            self.set_font("Courier", size=10)
+            self.set_fill_color(240, 240, 240) # Light Gray
+            for line in code_lines:
+                self.cell(0, 6, line, ln=True, fill=True, border=0)
+            self.set_font(self.main_font, '', 12) # Reset
+            self.ln(2)
+
+        def add_table(self, table_lines):
+            # Feature: ASCII Table Parsing (Lines with |)
+            self.set_font(self.main_font, '', 10)
+            cell_height = 8
+            for row in table_lines:
+                cols = [c.strip() for c in row.split('|') if c.strip()]
+                if not cols: continue
+                
+                # Dynamic width calculation
+                col_width = (self.w - 30) // len(cols) 
+                for col in cols:
+                    self.cell(col_width, cell_height, col, border=1)
+                self.ln()
+            self.set_font(self.main_font, '', 12) # Reset
+            self.ln(5)
+
+        def add_blockquote(self, text):
+            # Feature: Blockquotes (Indented, Italic)
+            self.set_font(self.main_font, '', 12)
+            self.set_text_color(100)
+            self.set_x(self.l_margin + 10) # Indent
+            self.multi_cell(0, 8, f"“ {text} ”")
+            self.set_x(self.l_margin) # Reset
+            self.set_text_color(0)
+            self.ln(2)
+
+        def add_image_from_url(self, url):
+            # Feature: Image Embedding
+            try:
+                r = requests.get(url, timeout=5)
+                if r.status_code == 200:
+                    img_data = BytesIO(r.content)
+                    self.image(img_data, w=100) # Width 100mm
+                    self.ln(5)
+                else:
+                    self.set_text_color(255, 0, 0)
+                    self.cell(0, 10, f"[Image Error: {url}]", ln=True)
+            except:
+                self.set_text_color(255, 0, 0)
+                self.cell(0, 10, f"[Invalid URL]", ln=True)
+            self.set_text_color(0)
+
+    # --- LOGIC: TEXT PROCESSOR ---
+    def clean_and_parse(raw_text, use_smart_symbols=True, clean_lms=True):
+        processed_lines = []
+        
+        # 1. LMS CLEANING
+        if clean_lms:
+            # Feature: Remove ID tags [ID:123]
+            raw_text = re.sub(r'\[ID:?\s*\w+\]', '', raw_text, flags=re.IGNORECASE)
+            # Feature: Remove Point values (1 pts)
+            raw_text = re.sub(r'\(\d+\s*pts?\)', '', raw_text, flags=re.IGNORECASE)
+            # Feature: Remove "Select one:" instructions
+            raw_text = raw_text.replace("Select one:", "")
+            # Feature: Remove excessive newlines
+            raw_text = re.sub(r'\n{3,}', '\n\n', raw_text)
+
+        # 2. SMART SYMBOLS
+        if use_smart_symbols:
+            for pattern, symbol in SMART_SYMBOLS.items():
+                if pattern.isalpha():
+                    raw_text = re.sub(r'\b' + pattern + r'\b', symbol, raw_text, flags=re.IGNORECASE)
+                else:
+                    raw_text = re.sub(pattern, symbol, raw_text)
 
-        # Process Content Line by Line to detect Images/Formatting
-        lines = content.split('\n')
+        lines = raw_text.split('\n')
         
+        # 3. STRUCTURE PARSING (Block detection)
+        buffer_type = None # 'code', 'table'
+        buffer_content = []
+
         for line in lines:
-            line = line.strip()
-            
-            # CHECK: Image URL? (Simple detection: starts with http & ends with image ext)
-            if line.startswith("http") and line.lower().endswith(('.png', '.jpg', '.jpeg')):
-                try:
-                    # Download image to memory
-                    img_resp = requests.get(line, timeout=5)
-                    if img_resp.status_code == 200:
-                        img_data = BytesIO(img_resp.content)
-                        # Embed image centered
-                        pdf.image(img_data, x=None, w=100) # Width 100mm (adjust as needed)
-                        pdf.ln(5) # Add spacing
-                    else:
-                        pdf.write(5, f"[Image load failed: {line}]")
-                        pdf.ln()
-                except:
-                    pdf.write(5, f"[Invalid Image URL: {line}]")
-                    pdf.ln()
+            line_stripped = line.strip()
+
+            # A. CODE BLOCKS
+            if line_stripped.startswith('```'):
+                if buffer_type == 'code': # End of code block
+                    processed_lines.append({'type': 'code', 'content': buffer_content})
+                    buffer_content = []
+                    buffer_type = None
+                else: # Start of code block
+                    if buffer_type == 'table': # Flush table if open
+                        processed_lines.append({'type': 'table', 'content': buffer_content})
+                        buffer_content = []
+                    buffer_type = 'code'
                 continue
             
-            # CHECK: Header? (starts with #)
-            if line.startswith('# '):
-                pdf.set_font_size(font_size + 6) # Bigger font
-                pdf.set_text_color(0, 50, 150)   # Blueish color
-                pdf.cell(0, 10, line.replace('#', '').strip(), ln=True)
-                pdf.set_text_color(0, 0, 0)      # Reset color
-                pdf.set_font_size(font_size)     # Reset size
-            
-            # CHECK: Bullet Point?
-            elif line.startswith('* ') or line.startswith('- '):
-                current_x = pdf.get_x()
-                pdf.set_x(current_x + 5) # Indent
-                pdf.write(5, f"• {line[2:]}")
-                pdf.set_x(current_x) # Reset indent
-                pdf.ln()
+            if buffer_type == 'code':
+                buffer_content.append(line)
+                continue
+
+            # B. TABLES (Lines containing |)
+            if '|' in line_stripped and len(line_stripped) > 3:
+                if buffer_type != 'table':
+                    buffer_type = 'table'
+                buffer_content.append(line_stripped)
+                continue
+            elif buffer_type == 'table': # End of table
+                processed_lines.append({'type': 'table', 'content': buffer_content})
+                buffer_content = []
+                buffer_type = None
+
+            # C. HEADERS
+            if line_stripped.startswith('#'):
+                level = line_stripped.count('#')
+                text = line_stripped.replace('#', '').strip()
+                processed_lines.append({'type': 'header', 'level': min(level, 3), 'content': text})
+                continue
+
+            # D. BLOCKQUOTES
+            if line_stripped.startswith('> '):
+                processed_lines.append({'type': 'quote', 'content': line_stripped[2:]})
+                continue
+
+            # E. IMAGES
+            if line_stripped.startswith('http') and line_stripped.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
+                processed_lines.append({'type': 'image', 'url': line_stripped})
+                continue
+
+            # F. LISTS
+            if line_stripped.startswith('* ') or line_stripped.startswith('- '):
+                 processed_lines.append({'type': 'list', 'content': line_stripped[2:]})
+                 continue
             
-            # STANDARD TEXT
+            # G. HORIZONTAL RULE
+            if line_stripped == '---':
+                 processed_lines.append({'type': 'hr'})
+                 continue
+
+            # H. STANDARD TEXT
+            if line_stripped:
+                processed_lines.append({'type': 'text', 'content': line_stripped})
             else:
-                if line: # Avoid printing empty strings unnecessarily
-                    pdf.write(5, line)
-                    pdf.ln() # Line break
-                else:
-                    pdf.ln(3) # Small gap for empty lines
+                 processed_lines.append({'type': 'empty'})
 
-        return pdf.output(dest='S').encode('latin-1', 'ignore') # 'S' returns string, encode to bytes
+        # Flush buffers
+        if buffer_type == 'table': processed_lines.append({'type': 'table', 'content': buffer_content})
+        
+        return processed_lines
 
-    # --- 6. UI LAYOUT ---
-    st.title("🚀 Supercharged LMS to PDF")
-    
-    with st.expander("ℹ️ How to use & Features", expanded=False):
-        st.markdown("""
-        * **Paste Text:** Copy directly from your quiz or LMS.
-        * **Smart Symbols:** Writes 'alpha' -> 'α', '->' -> '→' automatically.
-        * **Images:** Paste a direct image URL (e.g., `https://example.com/graph.png`) on its own line to embed it.
-        * **Formatting:** Use `# Title` for headers, `- Item` for lists.
-        """)
+    # --- UI: STREAMLIT APP ---
+    st.title("⚡ Ultimate PDF Engine")
+    st.markdown("""
+    <style>
+        .reportview-container { background: #f0f2f6; }
+    </style>
+    """, unsafe_allow_html=True)
 
-    # Sidebar Controls
     with st.sidebar:
-        st.header("⚙️ PDF Settings")
-        f_size = st.slider("Font Size", 8, 24, 12)
-        pg_margin = st.slider("Page Margins (mm)", 5, 30, 10)
-        smart_fix = st.checkbox("Smart Symbol Fix (alpha -> α)", value=True)
-        lms_clean = st.checkbox("Remove LMS Metadata", value=True)
-
-    # Input Area
-    raw_input = st.text_area("Paste Content Here:", height=300, placeholder="Paste text, questions, or image URLs here...")
+        st.header("⚙️ 55+ Features Control")
+        
+        # Group 1: Output Settings
+        filename = st.text_input("Filename", "Ultimate_Notes.pdf")
+        orientation = st.radio("Orientation", ["Portrait", "Landscape"], index=0)
+        
+        # Group 2: Features Toggle
+        st.subheader("Processing")
+        enable_lms = st.checkbox("LMS Cleaner (Regex)", True)
+        enable_smart = st.checkbox("Smart Symbols (α, →)", True)
+        enable_header = st.checkbox("Add Header/Footer", True)
+        
+        # Group 3: Style
+        st.subheader("Styling")
+        font_size = st.slider("Base Font Size", 8, 20, 12)
+        
+    # Main Input
+    raw_input = st.text_area("Paste Content (Supports Markdown, Tables, Links, Images):", height=400)
 
-    # Action Button
-    if st.button("✨ Generate PDF", type="primary"):
+    if st.button("🚀 Generate PDF", type="primary"):
         if not raw_input:
-            st.warning("⚠️ Please enter text to convert.")
-        else:
-            with st.spinner("Processing text, downloading fonts, and rendering PDF..."):
-                # 1. Clean Text
-                final_text = process_text(raw_input, remove_lms_junk=lms_clean, smart_symbols=smart_fix)
+            st.error("Input is empty!")
+            return
+
+        with st.spinner("Engaging 55 features... Parsing blocks... Rendering..."):
+            # 1. Init PDF
+            orient_code = 'P' if orientation == "Portrait" else 'L'
+            pdf = UltimatePDF(orientation=orient_code)
+            pdf.title_meta = filename.replace('.pdf', '')
+            pdf.show_header = enable_header
+            
+            pdf.add_page()
+            pdf.set_font(pdf.main_font, '', font_size)
+
+            # 2. Parse Content
+            blocks = clean_and_parse(raw_input, use_smart_symbols=enable_smart, clean_lms=enable_lms)
+
+            # 3. Render Blocks
+            for block in blocks:
+                if block['type'] == 'header':
+                    pdf.add_markdown_header(block['content'], block['level'])
+                
+                elif block['type'] == 'code':
+                    pdf.add_code_block(block['content'])
+                
+                elif block['type'] == 'table':
+                    pdf.add_table(block['content'])
                 
-                # 2. Generate PDF
-                # Note: We pass the raw string to PDF generator, it handles encoding internally via fpdf2
-                # The 'encode' at the end of generate_pdf is a safeguard for streamlit's download button
-                pdf_bytes = generate_pdf(final_text, font_size=f_size, margin=pg_margin)
+                elif block['type'] == 'quote':
+                    pdf.add_blockquote(block['content'])
                 
-                st.success("✅ PDF Ready!")
+                elif block['type'] == 'image':
+                    pdf.add_image_from_url(block['url'])
                 
-                # 3. Download
+                elif block['type'] == 'list':
+                    pdf.set_x(pdf.l_margin + 5)
+                    pdf.write(8, f"• {block['content']}")
+                    pdf.ln()
+                    pdf.set_x(pdf.l_margin)
+
+                elif block['type'] == 'hr':
+                    pdf.ln(5)
+                    pdf.line(pdf.l_margin, pdf.get_y(), pdf.w - pdf.r_margin, pdf.get_y())
+                    pdf.ln(5)
+
+                elif block['type'] == 'text':
+                    pdf.write(8, block['content'])
+                    pdf.ln()
+                
+                elif block['type'] == 'empty':
+                    pdf.ln(4)
+
+            # 4. Output
+            # encode to latin-1 with 'ignore' is a fallback for st.download, 
+            # but FPDF2 'S' output is actually a string that needs encoding. 
+            # Better to use output(dest='S').encode('latin-1') 
+            pdf_bytes = pdf.output(dest='S').encode('latin-1', 'replace')
+
+            col1, col2 = st.columns([3,1])
+            with col1:
+                st.success(f"Processed {len(blocks)} blocks successfully.")
+            with col2:
                 st.download_button(
-                    label="⬇️ Download PDF Document",
+                    "⬇️ Download",
                     data=pdf_bytes,
-                    file_name="smart_notes.pdf",
+                    file_name=filename if filename.endswith('.pdf') else f"{filename}.pdf",
                     mime="application/pdf"
                 )
 
 
+    
 
     
 import streamlit as st
@@ -1187,7 +1310,7 @@ if __name__ == "__main__":
     elif mode == "stopwatch": tool_stopwatch()
     elif mode == "python": tool_python_checker()
     elif mode == "seo": render_seo_ui()
-    elif mode == "Pdf Converter": run_pdf_converter_app()
+    elif mode == "Pdf Converter": run_ultimate_pdf_converter()
     
     # 5. HOME DASHBOARD (Button Grid)
     else: