Spaces:
Running
Running
| import logging | |
| import pathlib | |
| import re | |
| import tempfile | |
| from typing import List, Tuple | |
| import json5 | |
| import pptx | |
| from pptx.enum.shapes import MSO_AUTO_SHAPE_TYPE | |
| from global_config import GlobalConfig | |
| # English Metric Unit (used by PowerPoint) to inches | |
| EMU_TO_INCH_SCALING_FACTOR = 1.0 / 914400 | |
| INCHES_1_5 = pptx.util.Inches(1.5) | |
| INCHES_1 = pptx.util.Inches(1) | |
| INCHES_0_5 = pptx.util.Inches(0.5) | |
| INCHES_0_4 = pptx.util.Inches(0.4) | |
| INCHES_0_3 = pptx.util.Inches(0.3) | |
| STEP_BY_STEP_PROCESS_MARKER = '>> ' | |
| PATTERN = re.compile(r"^slide[ ]+\d+:", re.IGNORECASE) | |
| SAMPLE_JSON_FOR_PPTX = ''' | |
| { | |
| "title": "Understanding AI", | |
| "slides": [ | |
| { | |
| "heading": "Introduction", | |
| "bullet_points": [ | |
| "Brief overview of AI", | |
| [ | |
| "Importance of understanding AI" | |
| ] | |
| ] | |
| } | |
| ] | |
| } | |
| ''' | |
| logger = logging.getLogger(__name__) | |
| def remove_slide_number_from_heading(header: str) -> str: | |
| """ | |
| Remove the slide number from a given slide header. | |
| :param header: The header of a slide. | |
| """ | |
| if PATTERN.match(header): | |
| idx = header.find(':') | |
| header = header[idx + 1:] | |
| return header | |
| def generate_powerpoint_presentation( | |
| structured_data: str, | |
| slides_template: str, | |
| output_file_path: pathlib.Path | |
| ) -> List: | |
| """ | |
| Create and save a PowerPoint presentation file containing the content in JSON format. | |
| :param structured_data: The presentation contents as "JSON" (may contain trailing commas). | |
| :param slides_template: The PPTX template to use. | |
| :param output_file_path: The path of the PPTX file to save as. | |
| :return A list of presentation title and slides headers. | |
| """ | |
| # The structured "JSON" might contain trailing commas, so using json5 | |
| parsed_data = json5.loads(structured_data) | |
| logger.debug( | |
| '*** Using PPTX template: %s', | |
| GlobalConfig.PPTX_TEMPLATE_FILES[slides_template]['file'] | |
| ) | |
| presentation = pptx.Presentation(GlobalConfig.PPTX_TEMPLATE_FILES[slides_template]['file']) | |
| slide_width_inch, slide_height_inch = _get_slide_width_height_inches(presentation) | |
| # The title slide | |
| title_slide_layout = presentation.slide_layouts[0] | |
| slide = presentation.slides.add_slide(title_slide_layout) | |
| title = slide.shapes.title | |
| subtitle = slide.placeholders[1] | |
| title.text = parsed_data['title'] | |
| logger.info( | |
| 'PPT title: %s | #slides: %d', | |
| title.text, len(parsed_data['slides']) | |
| ) | |
| subtitle.text = 'by Myself and SlideDeck AI :)' | |
| all_headers = [title.text, ] | |
| # Add content in a loop | |
| for a_slide in parsed_data['slides']: | |
| is_processing_done = _handle_double_col_layout( | |
| presentation=presentation, | |
| slide_json=a_slide, | |
| slide_width_inch=slide_width_inch, | |
| slide_height_inch=slide_height_inch | |
| ) | |
| if not is_processing_done: | |
| is_processing_done = _handle_step_by_step_process( | |
| presentation=presentation, | |
| slide_json=a_slide, | |
| slide_width_inch=slide_width_inch, | |
| slide_height_inch=slide_height_inch | |
| ) | |
| if not is_processing_done: | |
| _handle_default_display( | |
| presentation=presentation, | |
| slide_json=a_slide, | |
| slide_width_inch=slide_width_inch, | |
| slide_height_inch=slide_height_inch | |
| ) | |
| # The thank-you slide | |
| last_slide_layout = presentation.slide_layouts[0] | |
| slide = presentation.slides.add_slide(last_slide_layout) | |
| title = slide.shapes.title | |
| title.text = 'Thank you!' | |
| presentation.save(output_file_path) | |
| return all_headers | |
| def get_flat_list_of_contents(items: list, level: int) -> List[Tuple]: | |
| """ | |
| Flatten a (hierarchical) list of bullet points to a single list containing each item and | |
| its level. | |
| :param items: A bullet point (string or list). | |
| :param level: The current level of hierarchy. | |
| :return: A list of (bullet item text, hierarchical level) tuples. | |
| """ | |
| flat_list = [] | |
| for item in items: | |
| if isinstance(item, str): | |
| flat_list.append((item, level)) | |
| elif isinstance(item, list): | |
| flat_list = flat_list + get_flat_list_of_contents(item, level + 1) | |
| return flat_list | |
| def _handle_default_display( | |
| presentation: pptx.Presentation, | |
| slide_json: dict, | |
| slide_width_inch: float, | |
| slide_height_inch: float | |
| ): | |
| """ | |
| Display a list of text in a slide. | |
| :param presentation: The presentation object. | |
| :param slide_json: The content of the slide as JSON data. | |
| :param slide_width_inch: The width of the slide in inches. | |
| :param slide_height_inch: The height of the slide in inches. | |
| """ | |
| bullet_slide_layout = presentation.slide_layouts[1] | |
| slide = presentation.slides.add_slide(bullet_slide_layout) | |
| shapes = slide.shapes | |
| title_shape = shapes.title | |
| body_shape = shapes.placeholders[1] | |
| title_shape.text = remove_slide_number_from_heading(slide_json['heading']) | |
| text_frame = body_shape.text_frame | |
| # The bullet_points may contain a nested hierarchy of JSON arrays | |
| # In some scenarios, it may contain objects (dictionaries) because the LLM generated so | |
| # ^ The second scenario is not covered | |
| flat_items_list = get_flat_list_of_contents(slide_json['bullet_points'], level=0) | |
| for idx, an_item in enumerate(flat_items_list): | |
| if idx == 0: | |
| text_frame.text = an_item[0].removeprefix(STEP_BY_STEP_PROCESS_MARKER) | |
| else: | |
| paragraph = text_frame.add_paragraph() | |
| paragraph.text = an_item[0].removeprefix(STEP_BY_STEP_PROCESS_MARKER) | |
| paragraph.level = an_item[1] | |
| _handle_key_message( | |
| the_slide=slide, | |
| slide_json=slide_json, | |
| slide_height_inch=slide_height_inch, | |
| slide_width_inch=slide_width_inch | |
| ) | |
| def _handle_double_col_layout( | |
| presentation: pptx.Presentation(), | |
| slide_json: dict, | |
| slide_width_inch: float, | |
| slide_height_inch: float | |
| ) -> bool: | |
| """ | |
| Add a slide with a double column layout for comparison. | |
| :param presentation: The presentation object. | |
| :param slide_json: The content of the slide as JSON data. | |
| :param slide_width_inch: The width of the slide in inches. | |
| :param slide_height_inch: The height of the slide in inches. | |
| :return: True if double col layout has been added; False otherwise. | |
| """ | |
| if 'bullet_points' in slide_json and slide_json['bullet_points']: | |
| double_col_content = slide_json['bullet_points'] | |
| if double_col_content and ( | |
| len(double_col_content) == 2 | |
| ) and isinstance(double_col_content[0], dict) and isinstance(double_col_content[1], dict): | |
| slide = presentation.slide_layouts[4] | |
| slide = presentation.slides.add_slide(slide) | |
| shapes = slide.shapes | |
| title_placeholder = shapes.title | |
| title_placeholder.text = remove_slide_number_from_heading(slide_json['heading']) | |
| left_heading, right_heading = shapes.placeholders[1], shapes.placeholders[3] | |
| left_col, right_col = shapes.placeholders[2], shapes.placeholders[4] | |
| left_col_frame, right_col_frame = left_col.text_frame, right_col.text_frame | |
| if 'heading' in double_col_content[0]: | |
| left_heading.text = double_col_content[0]['heading'] | |
| if 'bullet_points' in double_col_content[0]: | |
| flat_items_list = get_flat_list_of_contents( | |
| double_col_content[0]['bullet_points'], level=0 | |
| ) | |
| for idx, an_item in enumerate(flat_items_list): | |
| if idx == 0: | |
| left_col_frame.text = an_item[0].removeprefix(STEP_BY_STEP_PROCESS_MARKER) | |
| else: | |
| paragraph = left_col_frame.add_paragraph() | |
| paragraph.text = an_item[0].removeprefix(STEP_BY_STEP_PROCESS_MARKER) | |
| paragraph.level = an_item[1] | |
| if 'heading' in double_col_content[1]: | |
| right_heading.text = double_col_content[1]['heading'] | |
| if 'bullet_points' in double_col_content[1]: | |
| flat_items_list = get_flat_list_of_contents( | |
| double_col_content[1]['bullet_points'], level=0 | |
| ) | |
| for idx, an_item in enumerate(flat_items_list): | |
| if idx == 0: | |
| right_col_frame.text = an_item[0].removeprefix(STEP_BY_STEP_PROCESS_MARKER) | |
| else: | |
| paragraph = right_col_frame.add_paragraph() | |
| paragraph.text = an_item[0].removeprefix(STEP_BY_STEP_PROCESS_MARKER) | |
| paragraph.level = an_item[1] | |
| _handle_key_message( | |
| the_slide=slide, | |
| slide_json=slide_json, | |
| slide_height_inch=slide_height_inch, | |
| slide_width_inch=slide_width_inch | |
| ) | |
| return True | |
| return False | |
| def _handle_step_by_step_process( | |
| presentation: pptx.Presentation, | |
| slide_json: dict, | |
| slide_width_inch: float, | |
| slide_height_inch: float | |
| ) -> bool: | |
| """ | |
| Add shapes to display a step-by-step process in the slide, if available. | |
| :param presentation: The presentation object. | |
| :param slide_json: The content of the slide as JSON data. | |
| :param slide_width_inch: The width of the slide in inches. | |
| :param slide_height_inch: The height of the slide in inches. | |
| :return True if this slide has a step-by-step process depiction added; False otherwise. | |
| """ | |
| if 'bullet_points' in slide_json and slide_json['bullet_points']: | |
| steps = slide_json['bullet_points'] | |
| no_marker_count = 0.0 | |
| n_steps = len(steps) | |
| # Ensure that it is a single list of strings without any sub-list | |
| for step in steps: | |
| if not isinstance(step, str): | |
| return False | |
| # In some cases, one or two steps may not begin with >>, e.g.: | |
| # { | |
| # "heading": "Step-by-Step Process: Creating a Legacy", | |
| # "bullet_points": [ | |
| # "Identify your unique talents and passions", | |
| # ">> Develop your skills and knowledge", | |
| # ">> Create meaningful work", | |
| # ">> Share your work with the world", | |
| # ">> Continuously learn and adapt" | |
| # ], | |
| # "key_message": "" | |
| # }, | |
| # | |
| # Use a threshold, e.g., at most 20% | |
| if not step.startswith(STEP_BY_STEP_PROCESS_MARKER): | |
| no_marker_count += 1 | |
| slide_header = slide_json['heading'].lower() | |
| if (no_marker_count / n_steps > 0.25) and not ( | |
| ('step-by-step' in slide_header) or ('step by step' in slide_header) | |
| ): | |
| return False | |
| bullet_slide_layout = presentation.slide_layouts[1] | |
| slide = presentation.slides.add_slide(bullet_slide_layout) | |
| shapes = slide.shapes | |
| shapes.title.text = remove_slide_number_from_heading(slide_json['heading']) | |
| if 3 <= n_steps <= 4: | |
| # Horizontal display | |
| height = INCHES_1_5 | |
| width = pptx.util.Inches(slide_width_inch / n_steps - 0.01) | |
| top = pptx.util.Inches(slide_height_inch / 2) | |
| left = pptx.util.Inches((slide_width_inch - width.inches * n_steps) / 2 + 0.05) | |
| for step in steps: | |
| shape = shapes.add_shape(MSO_AUTO_SHAPE_TYPE.CHEVRON, left, top, width, height) | |
| shape.text = step.removeprefix(STEP_BY_STEP_PROCESS_MARKER) | |
| left += width - INCHES_0_4 | |
| elif 4 < n_steps <= 6: | |
| # Vertical display | |
| height = pptx.util.Inches(0.65) | |
| top = pptx.util.Inches(slide_height_inch / 4) | |
| left = INCHES_1 # slide_width_inch - width.inches) | |
| # Find the close to median width, based on the length of each text, to be set | |
| # for the shapes | |
| width = pptx.util.Inches(slide_width_inch * 2 / 3) | |
| lengths = [len(step) for step in steps] | |
| font_size_20pt = pptx.util.Pt(20) | |
| widths = sorted( | |
| [ | |
| min( | |
| pptx.util.Inches(font_size_20pt.inches * a_len), | |
| width | |
| ) for a_len in lengths | |
| ] | |
| ) | |
| width = widths[len(widths) // 2] | |
| for step in steps: | |
| shape = shapes.add_shape(MSO_AUTO_SHAPE_TYPE.PENTAGON, left, top, width, height) | |
| shape.text = step.removeprefix(STEP_BY_STEP_PROCESS_MARKER) | |
| top += height + INCHES_0_3 | |
| left += INCHES_0_5 | |
| else: | |
| # Two steps -- probably not a process | |
| # More than 5--6 steps -- would likely cause a visual clutter | |
| return False | |
| return True | |
| def _handle_key_message( | |
| the_slide: pptx.slide.Slide, | |
| slide_json: dict, | |
| slide_width_inch: float, | |
| slide_height_inch: float | |
| ): | |
| """ | |
| Add a shape to display the key message in the slide, if available. | |
| :param the_slide: The slide to be processed. | |
| :param slide_json: The content of the slide as JSON data. | |
| :param slide_width_inch: The width of the slide in inches. | |
| :param slide_height_inch: The height of the slide in inches. | |
| """ | |
| if 'key_message' in slide_json and slide_json['key_message']: | |
| height = pptx.util.Inches(1.6) | |
| width = pptx.util.Inches(slide_width_inch / 2.3) | |
| top = pptx.util.Inches(slide_height_inch - height.inches - 0.1) | |
| left = pptx.util.Inches((slide_width_inch - width.inches) / 2) | |
| shape = the_slide.shapes.add_shape( | |
| MSO_AUTO_SHAPE_TYPE.ROUNDED_RECTANGLE, | |
| left=left, | |
| top=top, | |
| width=width, | |
| height=height | |
| ) | |
| shape.text = slide_json['key_message'] | |
| def _get_slide_width_height_inches(presentation: pptx.Presentation) -> Tuple[float, float]: | |
| """ | |
| Get the dimensions of a slide in inches. | |
| :param presentation: The presentation object. | |
| :return: The width and the height. | |
| """ | |
| slide_width_inch = EMU_TO_INCH_SCALING_FACTOR * presentation.slide_width | |
| slide_height_inch = EMU_TO_INCH_SCALING_FACTOR * presentation.slide_height | |
| # logger.debug('Slide width: %f, height: %f', slide_width_inch, slide_height_inch) | |
| return slide_width_inch, slide_height_inch | |
| if __name__ == '__main__': | |
| _JSON_DATA = ''' | |
| { | |
| "title": "Understanding AI", | |
| "slides": [ | |
| { | |
| "heading": "Introduction", | |
| "bullet_points": [ | |
| "Brief overview of AI", | |
| [ | |
| "Importance of understanding AI" | |
| ] | |
| ], | |
| "key_message": "" | |
| }, | |
| { | |
| "heading": "What is AI?", | |
| "bullet_points": [ | |
| "Definition of AI", | |
| [ | |
| "Types of AI", | |
| [ | |
| "Narrow or weak AI", | |
| "General or strong AI" | |
| ] | |
| ], | |
| "Differences between AI and machine learning" | |
| ], | |
| "key_message": "" | |
| }, | |
| { | |
| "heading": "How AI Works", | |
| "bullet_points": [ | |
| "Overview of AI algorithms", | |
| [ | |
| "Types of AI algorithms", | |
| [ | |
| "Rule-based systems", | |
| "Decision tree systems", | |
| "Neural networks" | |
| ] | |
| ], | |
| "How AI processes data" | |
| ], | |
| "key_message": "" | |
| }, | |
| { | |
| "heading": "Building AI Models", | |
| "bullet_points": [ | |
| ">> Collect data", | |
| ">> Select model or architecture to use", | |
| ">> Set appropriate parameters", | |
| ">> Train model with data", | |
| ">> Run inference", | |
| ], | |
| "key_message": "" | |
| }, | |
| { | |
| "heading": "Pros and Cons: Deep Learning vs. Classical Machine Learning", | |
| "bullet_points": [ | |
| { | |
| "heading": "Classical Machine Learning", | |
| "bullet_points": [ | |
| "Interpretability: Easy to understand the model", | |
| "Faster Training: Quicker to train models", | |
| "Scalability: Can handle large datasets" | |
| ] | |
| }, | |
| { | |
| "heading": "Deep Learning", | |
| "bullet_points": [ | |
| "Handling Complex Data: Can learn from raw data", | |
| "Feature Extraction: Automatically learns features", | |
| "Improved Accuracy: Achieves higher accuracy" | |
| ] | |
| } | |
| ], | |
| "key_message": "" | |
| }, | |
| { | |
| "heading": "Pros of AI", | |
| "bullet_points": [ | |
| "Increased efficiency and productivity", | |
| "Improved accuracy and precision", | |
| "Enhanced decision-making capabilities", | |
| "Personalized experiences" | |
| ], | |
| "key_message": "AI can be used for many different purposes" | |
| }, | |
| { | |
| "heading": "Cons of AI", | |
| "bullet_points": [ | |
| "Job displacement and loss of employment", | |
| "Bias and discrimination", | |
| "Privacy and security concerns", | |
| "Dependence on technology" | |
| ], | |
| "key_message": "" | |
| }, | |
| { | |
| "heading": "Future Prospects of AI", | |
| "bullet_points": [ | |
| "Advancements in fields such as healthcare and finance", | |
| "Increased use" | |
| ], | |
| "key_message": "" | |
| } | |
| ] | |
| }''' | |
| temp = tempfile.NamedTemporaryFile(delete=False, suffix='.pptx') | |
| path = pathlib.Path(temp.name) | |
| generate_powerpoint_presentation( | |
| json5.loads(_JSON_DATA), | |
| output_file_path=path, | |
| slides_template='Basic' | |
| ) | |
| print(f'File path: {path}') | |
| temp.close() | |