app.py

import gradio as gr
import re
from pptx import Presentation
from pptx.util import Pt
from pptx.dml.color import RGBColor
from pptx.enum.shapes import PP_PLACEHOLDER
from pptx.enum.dml import MSO_FILL
from pptx.enum.text import PP_ALIGN
import os
import tempfile
import io

# --- 1. CONFIGURATION AND CONSTANTS ---

# List of common, web-safe fonts for the dropdown menu
COMMON_FONTS = [
    'Arial', 'Arial Black', 'Calibri', 'Calibri Light', 'Cambria', 'Candara',
    'Century Gothic', 'Consolas', 'Constantia', 'Corbel', 'Courier New',
    'Franklin Gothic Medium', 'Gabriola', 'Gadugi', 'Georgia', 'Gill Sans MT',
    'Impact', 'Lucida Console', 'Lucida Sans Unicode', 'Palatino Linotype',
    'Rockwell', 'Segoe UI', 'Sitka', 'Tahoma', 'Times New Roman',
    'Trebuchet MS', 'Verdana'
]

# Default styles that will populate the UI
DEFAULT_STYLES = {
    'title': {'font_name': 'Calibri', 'font_size': 44, 'bold': True, 'color': '#000000'},
    'subtitle': {'font_name': 'Calibri', 'font_size': 24, 'bold': False, 'color': '#333333'},
    'body_title': {'font_name': 'Calibri', 'font_size': 36, 'bold': True, 'color': '#000000'},
    'body_level_0': {'font_name': 'Calibri', 'font_size': 24, 'bold': False, 'color': '#1E1E1E'},
    'body_level_1': {'font_name': 'Calibri', 'font_size': 20, 'bold': False, 'color': '#1E1E1E'},
    'body_level_2': {'font_name': 'Calibri', 'font_size': 18, 'bold': False, 'color': '#1E1E1E'},
    'hyperlink': {'font_name': 'Calibri', 'font_size': 16, 'underline': True, 'color': '#0563C1'}
}

# Mapping for bullet points to indentation levels
BULLET_MAP = {'•': 0, '◦': 1, '▪': 2}
HYPERLINK_RE = re.compile(r'^(.*?):\s*(https?://\S+)$')


# --- 2. DEFAULT CONTENT AND EXAMPLES ---

DEFAULT_TEMPLATE = """
Slide 1: Title Slide
• AI-Powered Presentation Generator
• A Gradio & Python-pptx Project

Slide 2: Introduction
• Problem: Creating presentations is time-consuming.
• Solution: Automate slide generation from simple text outlines.
• Technology:
  ◦ Python for backend logic.
  ◦ `python-pptx` for presentation manipulation.
  ◦ Gradio for the user interface.

Slide 3: Key Features
• Text-to-Slide Conversion: Automatically creates slides from a formatted script.
• Full Customization:
  ◦ Control font styles, sizes, and colors for every element.
  ◦ Use built-in themes (like Dark Mode) or upload your own `.pptx` template.
• Intelligent Layouts:
  ▪ Differentiates between title slides and content slides.
  ▪ Supports multi-level bullet points.

Slide 4: How It Works
• Step 1: Write your content using the 'Slide X:' format.
• Step 2: Use the 'Customization' tab to tweak the design.
• Step 3: Click 'Create PowerPoint' to generate and download your file.
• More Info: https://github.com/gradio-app/gradio

Slide 5: Q&A
• Questions & Discussion
"""

MARKETING_PLAN_EXAMPLE = """
Slide 1: Title Slide
• Project Phoenix: Q3 Marketing Campaign

Slide 2: Campaign Goals
• Increase brand awareness by 20%.
• Generate 500 new qualified leads.
• Boost social media engagement by 30%.

Slide 3: Target Audience
• Tech startups in the AI sector.
• Mid-size e-commerce businesses.
• Digital marketing agencies.

Slide 4: Key Channels
• LinkedIn sponsored content & tech-focused blog partnerships.
• Targeted email campaigns & virtual webinar series.
• Link to our blog: https://gradio.app/blog

Slide 5: Budget Overview
• Content Creation: $5,000
• Paid Advertising: $10,000
• Total: $15,000

Slide 6: Next Steps & Q&A
"""

# --- 3. PRESENTATION GENERATION LOGIC ---

def parse_color_to_rgb(color_string):
    """Converts a color string (hex or rgb) to an RGBColor object."""
    if isinstance(color_string, str):
        if color_string.startswith('#'):
            return RGBColor.from_string(color_string.lstrip('#'))
        elif color_string.startswith('rgb'):
            try:
                r, g, b = map(int, re.findall(r'\d+', color_string))
                return RGBColor(r, g, b)
            except (ValueError, TypeError):
                return RGBColor(0, 0, 0)
    return RGBColor(0, 0, 0)

def apply_font_style(run, style_config):
    """Applies a dictionary of style attributes to a text run."""
    font = run.font
    for key, value in style_config.items():
        if key == 'color':
            font.color.rgb = value
        elif key == 'font_size':
            font.size = Pt(value)
        elif key == 'font_name':
            font.name = value
        else:
            setattr(font, key, value)

def find_placeholder(slide, placeholder_enums):
    """Finds a placeholder shape on a slide."""
    for shape in slide.shapes:
        if shape.is_placeholder and shape.placeholder_format.type in placeholder_enums:
            return shape
    return None

def populate_title_slide(slide, lines, style_config):
    """Populates a title slide with content and styles using a robust run-based approach."""
    title_ph = find_placeholder(slide, [PP_PLACEHOLDER.TITLE, PP_PLACEHOLDER.CENTER_TITLE])
    subtitle_ph = find_placeholder(slide, [PP_PLACEHOLDER.SUBTITLE])

    title_val = "Title Not Found"
    subtitle_vals = [line.lstrip('• ').strip() for line in lines if line.strip()]
    if subtitle_vals:
        title_val = subtitle_vals.pop(0)

    if title_ph and title_ph.has_text_frame:
        tf = title_ph.text_frame
        tf.clear()
        p = tf.add_paragraph() # Create a fresh paragraph
        p.alignment = PP_ALIGN.CENTER
        run = p.add_run()
        run.text = title_val
        apply_font_style(run, style_config['title'])
        # Remove the empty paragraph that might be left by tf.clear()
        if len(tf.paragraphs) > 1:
            tf._element.remove(tf.paragraphs[0]._p)


    if subtitle_ph and subtitle_ph.has_text_frame:
        tf = subtitle_ph.text_frame
        tf.clear()
        p = tf.add_paragraph()
        p.alignment = PP_ALIGN.CENTER
        
        for i, line_text in enumerate(subtitle_vals):
            if i > 0:
                p.add_run().text = '\n'
            
            run = p.add_run()
            run.text = line_text
            apply_font_style(run, style_config['subtitle'])
        if len(tf.paragraphs) > 1:
            tf._element.remove(tf.paragraphs[0]._p)


def populate_content_slide(slide, title, lines, style_config):
    """Populates a content slide with a title and bullet points using a robust run-based approach."""
    title_ph = find_placeholder(slide, [PP_PLACEHOLDER.TITLE])
    body_ph = find_placeholder(slide, [PP_PLACEHOLDER.BODY, PP_PLACEHOLDER.OBJECT])

    if title_ph and title_ph.has_text_frame:
        tf = title_ph.text_frame
        tf.clear()
        p = tf.add_paragraph()
        run = p.add_run()
        run.text = title
        apply_font_style(run, style_config['body_title'])
        if len(tf.paragraphs) > 1:
            tf._element.remove(tf.paragraphs[0]._p)


    if body_ph and body_ph.has_text_frame:
        tf = body_ph.text_frame
        tf.clear() 

        for line in lines:
            clean_line = line.strip()
            if not clean_line: continue

            p = tf.add_paragraph() # Always create a new paragraph for each line

            hyperlink_match = HYPERLINK_RE.match(clean_line.lstrip('•◦▪ '))
            if hyperlink_match:
                link_text, url = hyperlink_match.groups()
                run = p.add_run()
                run.text = f"{link_text}: {url}"
                run.hyperlink.address = url
                apply_font_style(run, style_config['hyperlink'])
                continue

            if clean_line.startswith(('•', '◦', '▪')):
                level = BULLET_MAP.get(clean_line[0], 0)
                text = clean_line[1:].lstrip()
                p.level = level
                run = p.add_run()
                # --- FIX: Include the bullet character in the run's text ---
                # This ensures the custom style (including color) applies to the bullet itself.
                run.text = f"{clean_line[0]} {text}"
                style_key = f'body_level_{level}'
                apply_font_style(run, style_config.get(style_key, style_config['body_level_0']))
            else:
                p.level = 0
                run = p.add_run()
                run.text = clean_line
                apply_font_style(run, style_config['body_level_0'])
        
        # After loop, remove the initial empty paragraph if it exists
        if len(tf.paragraphs) > 0 and not tf.paragraphs[0].text.strip():
             tf._element.remove(tf.paragraphs[0]._p)


def create_presentation_file(content, template_path, style_config):
    """Main function to create the presentation file from text, a template, and styles."""
    try:
        prs = Presentation(template_path) if template_path else Presentation()
    except Exception as e:
        raise gr.Error(f"Could not load the presentation template. Please ensure it's a valid .pptx file. Error: {e}")

    if template_path and len(prs.slides) > 0:
        title_layout = prs.slides[0].slide_layout
        content_layout = prs.slides[1].slide_layout if len(prs.slides) > 1 else prs.slides[0].slide_layout
    else:
        # Default layouts for blank presentation
        title_layout = prs.slide_layouts[0] if len(prs.slide_layouts) > 0 else prs.slide_layouts[5]
        content_layout = prs.slide_layouts[1] if len(prs.slide_layouts) > 1 else prs.slide_layouts[0]


    slides_data = re.split(r'\nSlide \d+[a-zA-Z]?:', content, flags=re.IGNORECASE)
    slides_data = [s.strip() for s in slides_data if s.strip()]
    if not slides_data:
        raise gr.Error("The input text does not contain any valid slides. Please use the format 'Slide X:'.")

    for i in range(len(prs.slides) - 1, -1, -1):
        rId = prs.slides._sldIdLst[i].rId
        prs.part.drop_rel(rId)
        del prs.slides._sldIdLst[i]

    for i, slide_content in enumerate(slides_data):
        lines = [line.strip() for line in slide_content.split('\n') if line.strip()]
        if not lines: continue

        slide_title_text = lines.pop(0)

        if i == 0 and "title slide" in slide_title_text.lower():
            slide = prs.slides.add_slide(title_layout)
            populate_title_slide(slide, lines, style_config)
        else:
            slide = prs.slides.add_slide(content_layout)
            populate_content_slide(slide, slide_title_text, lines, style_config)

    with tempfile.NamedTemporaryFile(delete=False, suffix=".pptx") as tmp:
        prs.save(tmp.name)
        return tmp.name

def create_themed_template(theme):
    """Creates a temporary .pptx file with a themed background."""
    prs = Presentation()
    slide_master = prs.slide_masters[0]
    fill = slide_master.background.fill

    if theme == "Dark":
        fill.solid()
        fill.fore_color.rgb = RGBColor(0x1E, 0x1E, 0x1E)
    elif theme == "Blue":
        fill.solid()
        fill.fore_color.rgb = RGBColor(0xE7, 0xF1, 0xFF)

    with tempfile.NamedTemporaryFile(delete=False, suffix=".pptx") as tmp:
        prs.save(tmp.name)
        return tmp.name

def main_interface(*args):
    """Collects all UI inputs and generates the presentation."""
    (
        content, template_choice, custom_template_file,
        title_font, title_size, title_bold, title_color,
        subtitle_font, subtitle_size, subtitle_bold, subtitle_color,
        body_title_font, body_title_size, body_title_bold, body_title_color,
        L0_font, L0_size, L0_bold, L0_color,
        L1_font, L1_size, L1_bold, L1_color,
        L2_font, L2_size, L2_bold, L2_color
    ) = args

    if not content:
        raise gr.Error("Presentation content is empty. Please enter your text first.")

    template_path = None
    if custom_template_file is not None:
        template_path = custom_template_file.name
    elif template_choice != "Default White":
        template_path = create_themed_template(template_choice)

    hyperlink_style = DEFAULT_STYLES['hyperlink'].copy()
    hyperlink_style['color'] = parse_color_to_rgb(hyperlink_style['color'])

    style_config = {
        'title': {'font_name': title_font, 'font_size': title_size, 'bold': title_bold, 'color': parse_color_to_rgb(title_color)},
        'subtitle': {'font_name': subtitle_font, 'font_size': subtitle_size, 'bold': subtitle_bold, 'color': parse_color_to_rgb(subtitle_color)},
        'body_title': {'font_name': body_title_font, 'font_size': body_title_size, 'bold': body_title_bold, 'color': parse_color_to_rgb(body_title_color)},
        'body_level_0': {'font_name': L0_font, 'font_size': L0_size, 'bold': L0_bold, 'color': parse_color_to_rgb(L0_color)},
        'body_level_1': {'font_name': L1_font, 'font_size': L1_size, 'bold': L1_bold, 'color': parse_color_to_rgb(L1_color)},
        'body_level_2': {'font_name': L2_font, 'font_size': L2_size, 'bold': L2_bold, 'color': parse_color_to_rgb(L2_color)},
        'hyperlink': hyperlink_style
    }

    output_path = create_presentation_file(content, template_path, style_config)
    return output_path

# --- 4. GRADIO UI ---
with gr.Blocks(theme=gr.themes.Soft(), css="footer {display: none !important}") as app:
    gr.Markdown("""
    <div style="text-align: center; padding: 20px; background-image: linear-gradient(to right, #74ebd5, #acb6e5); color: white; border-radius: 12px; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
        <h1 style="font-size: 2.8em; margin: 0; font-weight: 700; text-shadow: 1px 1px 3px rgba(0,0,0,0.2);">✨ AI Presentation Architect</h1>
        <p style="font-size: 1.2em; margin-top: 5px;">Craft stunning presentations from simple text. Customize everything.</p>
    </div>
    """)

    with gr.Tabs():
        with gr.TabItem("📝 Content & Generation"):
            with gr.Row(equal_height=True):
                with gr.Column(scale=2):
                    gr.Markdown("### 1. Enter Presentation Content")
                    presentation_text_area = gr.Textbox(
                        label="Format: 'Slide 1: Title' followed by bullet points.",
                        lines=25,
                        value=DEFAULT_TEMPLATE.strip()
                    )
                    gr.Examples(
                        examples=[
                            [DEFAULT_TEMPLATE.strip()],
                            [MARKETING_PLAN_EXAMPLE.strip()]
                        ],
                        inputs=presentation_text_area,
                        label="Example Outlines"
                    )
                with gr.Column(scale=1):
                    gr.Markdown("### 2. Choose a Template")
                    template_radio = gr.Radio(
                        ["Default White", "Dark", "Blue"],
                        label="Built-in Blank Templates",
                        value="Default White"
                    )
                    gr.Markdown("<p style='text-align: center; margin: 10px 0;'>OR</p>")
                    template_upload = gr.File(label="Upload a Custom .pptx Template", file_types=[".pptx"])
                    with gr.Accordion("💡 Template Tips", open=False):
                        gr.Markdown("""
                        - An uploaded template will **override** the built-in choice.
                        - All existing slides in your template will be **removed** and replaced with the new content.
                        - The design (master slide) of your template will be preserved.
                        - For best results, use a template with standard 'Title' and 'Title and Content' layouts.
                        """)

                    gr.Markdown("### 3. Create & Download")
                    create_ppt_btn = gr.Button("🚀 Generate PowerPoint", variant="primary", scale=2)
                    output_file = gr.File(label="Download Your Presentation", interactive=False)

        with gr.TabItem("🎨 Font & Style Customization"):
            gr.Markdown("### Fine-tune the look and feel of your presentation text.")
            with gr.Accordion("Title & Subtitle Styles", open=True):
                with gr.Row():
                    title_font = gr.Dropdown(COMMON_FONTS, label="Title Font", value=DEFAULT_STYLES['title']['font_name'])
                    title_size = gr.Slider(10, 100, label="Title Size (pt)", value=DEFAULT_STYLES['title']['font_size'], step=1)
                    title_bold = gr.Checkbox(label="Bold", value=DEFAULT_STYLES['title']['bold'])
                    title_color = gr.ColorPicker(label="Color", value=DEFAULT_STYLES['title']['color'])
                with gr.Row():
                    subtitle_font = gr.Dropdown(COMMON_FONTS, label="Subtitle Font", value=DEFAULT_STYLES['subtitle']['font_name'])
                    subtitle_size = gr.Slider(10, 60, label="Subtitle Size (pt)", value=DEFAULT_STYLES['subtitle']['font_size'], step=1)
                    subtitle_bold = gr.Checkbox(label="Bold", value=DEFAULT_STYLES['subtitle']['bold'])
                    subtitle_color = gr.ColorPicker(label="Color", value=DEFAULT_STYLES['subtitle']['color'])

            with gr.Accordion("Content Body Styles", open=True):
                 with gr.Row():
                    body_title_font = gr.Dropdown(COMMON_FONTS, label="Slide Title Font", value=DEFAULT_STYLES['body_title']['font_name'])
                    body_title_size = gr.Slider(10, 80, label="Slide Title Size (pt)", value=DEFAULT_STYLES['body_title']['font_size'], step=1)
                    body_title_bold = gr.Checkbox(label="Bold", value=DEFAULT_STYLES['body_title']['bold'])
                    body_title_color = gr.ColorPicker(label="Color", value=DEFAULT_STYLES['body_title']['color'])
                 gr.HTML("<hr>")
                 with gr.Row():
                    L0_font = gr.Dropdown(COMMON_FONTS, label="Bullet Level 1 (•) Font", value=DEFAULT_STYLES['body_level_0']['font_name'])
                    L0_size = gr.Slider(8, 50, label="Size (pt)", value=DEFAULT_STYLES['body_level_0']['font_size'], step=1)
                    L0_bold = gr.Checkbox(label="Bold", value=DEFAULT_STYLES['body_level_0']['bold'])
                    L0_color = gr.ColorPicker(label="Color", value=DEFAULT_STYLES['body_level_0']['color'])
                 with gr.Row():
                    L1_font = gr.Dropdown(COMMON_FONTS, label="Bullet Level 2 (◦) Font", value=DEFAULT_STYLES['body_level_1']['font_name'])
                    L1_size = gr.Slider(8, 50, label="Size (pt)", value=DEFAULT_STYLES['body_level_1']['font_size'], step=1)
                    L1_bold = gr.Checkbox(label="Bold", value=DEFAULT_STYLES['body_level_1']['bold'])
                    L1_color = gr.ColorPicker(label="Color", value=DEFAULT_STYLES['body_level_1']['color'])
                 with gr.Row():
                    L2_font = gr.Dropdown(COMMON_FONTS, label="Bullet Level 3 (▪) Font", value=DEFAULT_STYLES['body_level_2']['font_name'])
                    L2_size = gr.Slider(8, 50, label="Size (pt)", value=DEFAULT_STYLES['body_level_2']['font_size'], step=1)
                    L2_bold = gr.Checkbox(label="Bold", value=DEFAULT_STYLES['body_level_2']['bold'])
                    L2_color = gr.ColorPicker(label="Color", value=DEFAULT_STYLES['body_level_2']['color'])

    # List of all input components to be passed to the main function
    all_inputs = [
        presentation_text_area, template_radio, template_upload,
        title_font, title_size, title_bold, title_color,
        subtitle_font, subtitle_size, subtitle_bold, subtitle_color,
        body_title_font, body_title_size, body_title_bold, body_title_color,
        L0_font, L0_size, L0_bold, L0_color,
        L1_font, L1_size, L1_bold, L1_color,
        L2_font, L2_size, L2_bold, L2_color
    ]

    create_ppt_btn.click(
        fn=main_interface,
        inputs=all_inputs,
        outputs=output_file
    )

if __name__ == "__main__":
    app.launch(debug=True, share=True)