Update app.py

app.py

@@ -8,8 +8,8 @@ import pikepdf
 import fpdf
 import fitz  # pymupdf
 import cv2
+import numpy as np
 from PIL import Image
-import imutils.video
 import io
 import os
 
@@ -31,14 +31,21 @@ ml_outline = [
 
 # Demo functions for PDF libraries
 def demo_pikepdf():
+    """Create a simple PDF with pikepdf"""
     pdf = pikepdf.Pdf.new()
-    pdf.pages.append(pikepdf.Page(pikepdf.Dictionary()))
+    page = pdf.make_indirect(pikepdf.Dictionary(
+        Type=pikepdf.Name.Page,
+        MediaBox=[0, 0, 595, 842],
+        Contents=pdf.make_stream(b"BT /F1 12 Tf 100 700 Td (PikePDF Demo) Tj ET")
+    ))
+    pdf.pages.append(page)
     buffer = io.BytesIO()
     pdf.save(buffer)
     buffer.seek(0)
     return buffer.getvalue()
 
 def demo_fpdf():
+    """Create a simple PDF with fpdf"""
     pdf = fpdf.FPDF()
     pdf.add_page()
     pdf.set_font("Arial", size=12)
@@ -49,6 +56,7 @@ def demo_fpdf():
     return buffer.getvalue()
 
 def demo_pymupdf():
+    """Create a simple PDF with pymupdf"""
     doc = fitz.open()
     page = doc.new_page()
     page.insert_text((100, 100), "PyMuPDF Demo")
@@ -57,26 +65,44 @@ def demo_pymupdf():
     buffer.seek(0)
     return buffer.getvalue()
 
-# Demo function for image capture (using OpenCV as representative)
+# Demo function for image capture
 def demo_image_capture():
+    """Generate a demo image (fake capture) since we can't access the camera in this environment"""
+    # Create a simple gradient image using numpy and PIL
+    width, height = 640, 480
+    
+    # Create a gradient array
+    x = np.linspace(0, 1, width)
+    y = np.linspace(0, 1, height)
+    xx, yy = np.meshgrid(x, y)
+    gradient = (xx + yy) / 2
+    
+    # Convert to RGB image
+    img_array = (gradient * 255).astype(np.uint8)
+    rgb_array = np.stack([img_array, img_array//2, img_array*2], axis=2)
+    
+    # Create PIL Image
+    img = Image.fromarray(rgb_array)
+    
+    # Add text to the image
+    from PIL import ImageDraw, ImageFont
+    draw = ImageDraw.Draw(img)
     try:
-        cap = cv2.VideoCapture(0)
-        ret, frame = cap.read()
-        if ret:
-            rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            img = Image.fromarray(rgb_frame)
-            buffer = io.BytesIO()
-            img.save(buffer, format="JPEG")
-            buffer.seek(0)
-            cap.release()
-            return buffer.getvalue()
-        cap.release()
+        font = ImageFont.truetype("arial.ttf", 30)
     except:
-        return None
-    return None
+        font = ImageFont.load_default()
+    
+    draw.text((width//4, height//2), "OpenCV Demo Image", fill=(255, 255, 255), font=font)
+    
+    # Save to buffer
+    buffer = io.BytesIO()
+    img.save(buffer, format="JPEG")
+    buffer.seek(0)
+    return buffer.getvalue()
 
 # Main PDF creation using ReportLab
 def create_main_pdf(outline_items):
+    """Create a two-page landscape PDF with the outline split between pages"""
     buffer = io.BytesIO()
     doc = SimpleDocTemplate(buffer, pagesize=(A4[1], A4[0]))  # Landscape
     styles = getSampleStyleSheet()
@@ -88,7 +114,7 @@ def create_main_pdf(outline_items):
     
     # Normal style
     normal_style = styles['Normal']
-    normal_style.fontSize = 10
+    normal_style.fontSize = 12
     normal_style.leading = 14
     
     # Page 1: Items 1-6
@@ -113,6 +139,7 @@ def create_main_pdf(outline_items):
     return buffer.getvalue()
 
 def get_binary_file_downloader_html(bin_data, file_label='File'):
+    """Create a download link for binary data"""
     bin_str = base64.b64encode(bin_data).decode()
     href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{file_label}">Download {file_label}</a>'
     return href
@@ -127,46 +154,54 @@ with col1:
     outline_text = "\n".join(ml_outline)
     st.markdown(outline_text)
     
-    md_file = "ml_outline.md"
-    with open(md_file, "w", encoding='utf-8') as f:
-        f.write(outline_text)
-    st.markdown(get_binary_file_downloader_html(outline_text.encode('utf-8'), "ml_outline.md"), unsafe_allow_html=True)
+    # Create a download button for the markdown file
+    st.download_button(
+        label="Download Markdown",
+        data=outline_text,
+        file_name="ml_outline.md",
+        mime="text/markdown"
+    )
 
 with col2:
     st.header("📑 PDF Preview & Demos")
     
     # Library Demos
     st.subheader("Library Demos")
-    if st.button("Run PDF Demos"):
+    if st.button("Run PDF Library Demos"):
         with st.spinner("Running demos..."):
-            # pikepdf demo
-            pike_pdf = demo_pikepdf()
-            st.download_button("Download pikepdf Demo", pike_pdf, "pikepdf_demo.pdf")
+            # Create tabs for each demo
+            demo_tabs = st.tabs(["PikePDF", "FPDF", "PyMuPDF", "Image Demo"])
             
-            # fpdf demo
-            fpdf_pdf = demo_fpdf()
-            st.download_button("Download fpdf Demo", fpdf_pdf, "fpdf_demo.pdf")
+            with demo_tabs[0]:
+                # pikepdf demo
+                pike_pdf = demo_pikepdf()
+                st.download_button("Download pikepdf Demo", pike_pdf, "pikepdf_demo.pdf")
+                st.write("PikePDF demo created successfully!")
             
-            # pymupdf demo
-            pymupdf_pdf = demo_pymupdf()
-            st.download_button("Download pymupdf Demo", pymupdf_pdf, "pymupdf_demo.pdf")
+            with demo_tabs[1]:
+                # fpdf demo
+                fpdf_pdf = demo_fpdf()
+                st.download_button("Download fpdf Demo", fpdf_pdf, "fpdf_demo.pdf")
+                st.write("FPDF demo created successfully!")
             
-            # Image capture demo
-            img_data = demo_image_capture()
-            if img_data:
-                st.image(img_data, caption="OpenCV Image Capture Demo")
-            else:
-                st.warning("Image capture demo failed - camera not detected")
+            with demo_tabs[2]:
+                # pymupdf demo
+                pymupdf_pdf = demo_pymupdf()
+                st.download_button("Download pymupdf Demo", pymupdf_pdf, "pymupdf_demo.pdf")
+                st.write("PyMuPDF demo created successfully!")
+            
+            with demo_tabs[3]:
+                # Image demo
+                img_data = demo_image_capture()
+                st.image(img_data, caption="Demo Image (Camera simulation)")
 
     # Main PDF Generation
+    st.subheader("Main Outline PDF")
     if st.button("Generate Main PDF"):
         with st.spinner("Generating PDF..."):
             try:
                 pdf_bytes = create_main_pdf(ml_outline)
                 
-                with open("ml_outline.pdf", "wb") as f:
-                    f.write(pdf_bytes)
-                
                 st.download_button(
                     label="Download Main PDF",
                     data=pdf_bytes,
@@ -174,6 +209,7 @@ with col2:
                     mime="application/pdf"
                 )
                 
+                # Display the PDF in the app
                 base64_pdf = base64.b64encode(pdf_bytes).decode('utf-8')
                 pdf_display = f'''
                     <embed 
@@ -183,14 +219,30 @@ with col2:
                         type="application/pdf">
                 '''
                 st.markdown(pdf_display, unsafe_allow_html=True)
+                
+                st.success("PDF generated successfully! You can view it above and download it using the button.")
             except Exception as e:
                 st.error(f"Error generating PDF: {str(e)}")
 
+# Add custom CSS for better appearance
 st.markdown("""
 <style>
     .stButton>button {
         background-color: #4CAF50;
         color: white;
+        font-weight: bold;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2px;
+    }
+    .stTabs [data-baseweb="tab"] {
+        height: 50px;
+        white-space: pre-wrap;
+        background-color: #f0f2f6;
+        border-radius: 4px 4px 0px 0px;
+        gap: 1px;
+        padding-top: 10px;
+        padding-bottom: 10px;
     }
 </style>
 """, unsafe_allow_html=True)