import re import traceback from dataclasses import dataclass from typing import Callable from pptx import Presentation as PPTXPre from pptx.enum.shapes import MSO_SHAPE_TYPE from pptx.oxml import parse_xml from pptx.shapes.autoshape import Shape as PPTXAutoShape from pptx.shapes.base import BaseShape from pptx.shapes.connector import Connector as PPTXConnector from pptx.shapes.group import GroupShape as PPTXGroupShape from pptx.shapes.picture import Picture as PPTXPicture from pptx.shapes.placeholder import PlaceholderPicture, SlidePlaceholder, TablePlaceholder from pptx.shapes.freeform import FreeformBuilder from pptx.slide import Slide as PPTXSlide from pptx.text.text import _Paragraph, _Run from rich import print from utils.src.utils import ( IMAGE_EXTENSIONS, Config, apply_fill, dict_to_object, extract_fill, get_font_pptcstyle, get_font_style, merge_dict, object_to_dict, parse_groupshape, pexists, pjoin, runs_merge, wmf_to_images, ) INDENT = "\t" # textframe: shape bounds font # paragraph: space, alignment, level, font bullet # run: font, hyperlink, text @dataclass class StyleArg: """ A class to represent style arguments for HTML conversion. """ paragraph_id: bool = True element_id: bool = True font_style: bool = True area: bool = False size: bool = False geometry: bool = False show_image: bool = True @dataclass class Closure: closure: Callable paragraph_id: int = -1 def apply(self, shape: BaseShape): """ Apply the closure to a shape. Args: shape (BaseShape): The shape to apply the closure to. """ self.closure(shape) def __gt__(self, other): if self.paragraph_id != other.paragraph_id: return self.paragraph_id > other.paragraph_id class Paragraph: def __init__(self, paragraph: _Paragraph, idx: int): run = runs_merge(paragraph) self.idx = idx self.real_idx = idx self.bullet = paragraph.bullet if run is None: self.idx = -1 return self.font = merge_dict( object_to_dict(paragraph.font), [object_to_dict(run.font)] ) self.text = re.sub(r"(_x000B_|\\x0b)", " ", paragraph.text) def to_html(self, style_args: StyleArg): if self.idx == -1: raise ValueError(f"paragraph {self.idx} is not valid") tag = "li" if self.bullet else "p" id_str = f" id='{self.idx}'" if style_args.paragraph_id else "" font_style = get_font_style(self.font) style_str = ( f" style='{font_style}'" if style_args.font_style and font_style else "" ) if self.bullet: style_str += f" bullet-type='{self.bullet}'" return f"<{tag}{id_str}{style_str}>{self.text}" def __repr__(self): return f"Paragraph-{self.idx}: {self.text}" class TextFrame: def __init__(self, shape: BaseShape, level: int): if not shape.has_text_frame: self.is_textframe = False return self.paragraphs = [ Paragraph(paragraph, idx) for idx, paragraph in enumerate(shape.text_frame.paragraphs) ] para_offset = 0 for para in self.paragraphs: if para.idx == -1: para_offset += 1 else: para.idx = para.idx - para_offset if len(self.paragraphs) == 0: self.is_textframe = False return self.level = level self.text = shape.text self.is_textframe = True self.font = merge_dict( object_to_dict(shape.text_frame.font), [para.font for para in self.paragraphs if para.idx != -1], ) def to_html(self, style_args: StyleArg): """ Convert the text frame to HTML. Args: style_args (StyleArg): The style arguments for HTML conversion. Returns: str: The HTML representation of the text frame. """ if not self.is_textframe: return "" repr_list = [ para.to_html(style_args) for para in self.paragraphs if para.idx != -1 ] return "\n".join([INDENT * self.level + repr for repr in repr_list]) def __repr__(self): if not self.is_textframe: return "TextFrame: null" return f"TextFrame: {self.paragraphs}" def __len__(self): if not self.is_textframe: return 0 return len(self.text) def to_pptc(self, father_idx: int) -> str: """ Convert the text frame to PPTC format. Args: father_idx (int): The index of the parent shape. Returns: str: The PPTC representation of the text frame. """ if not self.is_textframe: return "" s = f"[Text id={father_idx}]" for para in self.paragraphs: if para.idx == -1: continue s += f"\n" s += f"[Paragraph id={para.idx}]" s += get_font_pptcstyle(para.font) + f"\n" s += para.text + "\n" return s class ShapeElement: def __init__( self, slide_idx: int, shape_idx: int, style: dict, data: dict, text_frame: TextFrame, slide_area: float, level: int, ): self.slide_idx = slide_idx self.shape_idx = shape_idx self.style = style self.data = data self.text_frame = text_frame self._closure_keys = ["clone", "replace", "delete", "style"] self._closures: dict[str, list[Closure]] = { key: [] for key in self._closure_keys } self.slide_area = slide_area self.level = level @classmethod def from_shape( cls, slide_idx: int, shape_idx: int, shape: BaseShape, config: Config, slide_area: float, level: int = 0, ): """ Create a ShapeElement from a BaseShape. Args: slide_idx (int): The index of the slide. shape_idx (int): The index of the shape. shape (BaseShape): The shape object. config (Config): The configuration object. slide_area (float): The area of the slide. level (int): The indentation level. Returns: ShapeElement: The created ShapeElement. """ if shape_idx > 100 and isinstance(shape, PPTXGroupShape): raise ValueError(f"nested group shapes are not allowed") line = None if "line" in dir(shape) and shape.line._ln is not None: line = { "fill": extract_fill(shape.line), "width": shape.line.width, "dash_style": shape.line.dash_style, } fill = extract_fill(shape) style = { "shape_bounds": { "width": shape.width, "height": shape.height, "left": shape.left, "top": shape.top, }, "shape_type": str(shape.shape_type).split("(")[0].lower(), "rotation": shape.rotation, "fill": fill, "line": line, } text_frame = TextFrame(shape, level + 1) obj = SHAPECAST.get(shape.shape_type, UnsupportedShape).from_shape( slide_idx, shape_idx, shape, style, text_frame, config, slide_area, level, ) obj.xml = shape._element.xml # ? for debug, mask to enable pickling # obj.shape = shape return obj def build(self, slide: PPTXSlide): """ Build the shape element in a slide. Args: slide (PPTXSlide): The slide to build the shape in. Returns: The built shape. """ return slide.shapes._shape_factory( slide.shapes._spTree.insert_element_before(parse_xml(self.xml), "p:extLst") ) def __repr__(self) -> str: return f"{self.__class__.__name__}: shape {self.shape_idx} of slide {self.slide_idx}" def to_html(self, style_args: StyleArg) -> str: """ Convert the shape element to HTML. Args: style_args (StyleArg): The style arguments for HTML conversion. Returns: str: The HTML representation of the shape element. """ return "" @property def closures(self): """ Get the closures associated with the shape element. Returns: list: A list of closures. """ closures = [] closures.extend(sorted(self._closures["clone"])) closures.extend(self._closures["replace"] + self._closures["style"]) closures.extend(sorted(self._closures["delete"], reverse=True)) return closures @property def indent(self): return "\t" * self.level @property def left(self): return self.style["shape_bounds"]["left"].pt @left.setter def left(self, value): self.style["shape_bounds"]["left"] = value @property def top(self): return self.style["shape_bounds"]["top"].pt @top.setter def top(self, value): self.style["shape_bounds"]["top"] = value @property def width(self): return self.style["shape_bounds"]["width"].pt @width.setter def width(self, value): self.style["shape_bounds"]["width"] = value @property def height(self): return self.style["shape_bounds"]["height"].pt @height.setter def height(self, value): self.style["shape_bounds"]["height"] = value @property def area(self): """ Get the area of the shape element. Returns: float: The area in square points. """ return self.width * self.height @property def pptc_text_info(self): """ Get the PPTC text information of the shape element. Returns: str: The PPTC text information. """ if isinstance(self, Picture): return self.caption return self.text_frame.to_pptc(self.shape_idx) @property def pptc_space_info(self): """ Get the PPTC space information of the shape element. Returns: str: The PPTC space information. """ return f"Visual Positions: left={self.left}pt, top={self.top}pt\n" @property def pptc_size_info(self): """ Get the PPTC size information of the shape element. Returns: str: The PPTC size information. """ return f"Size: height={self.height}pt, width={self.width}pt\n" @property def pptc_description(self): """ Get the PPTC description of the shape element. Returns: str: The PPTC description. """ return f"[{self.__class__.__name__} id={self.shape_idx}]\n" def to_pptc(self): """ Convert the shape element to PPTC format. Returns: str: The PPTC representation of the shape element. """ s = "" s += self.pptc_description s += self.pptc_size_info s += self.pptc_space_info s += self.pptc_text_info return s def get_inline_style(self, style_args: StyleArg): """ Get the inline style for the shape element. Args: style_args (StyleArg): The style arguments for HTML conversion. Returns: str: The inline style string. """ id_str = f" id='{self.shape_idx}'" if style_args.element_id else "" styles = [] if style_args.area: styles.append(f"data-relative-area={self.area*100/self.slide_area:.2f}%;") if style_args.size: styles.append(f"width: {self.width}pt; height: {self.height}pt;") if style_args.geometry: styles.append(f"left: {self.left}pt; top: {self.top}pt;") if style_args.font_style and self.text_frame.is_textframe: font_style = get_font_style(self.text_frame.font) if font_style: styles.append(font_style) if len(styles) != 0: return id_str + " style='" + " ".join(styles) + "'" return id_str class UnsupportedShape(ShapeElement): @classmethod def from_shape( cls, slide_idx: int, shape_idx: int, shape: BaseShape, *args, **kwargs, ): raise ValueError(f"unsupported shape {shape.shape_type}") class TextBox(ShapeElement): @classmethod def from_shape( cls, slide_idx: int, shape_idx: int, shape: TextFrame, style: dict, text_frame: TextFrame, config: Config, slide_area: float, level: int, ): return cls(slide_idx, shape_idx, style, None, text_frame, slide_area, level) def to_html(self, style_args: StyleArg) -> str: return ( f"{self.indent}\n" + self.text_frame.to_html(style_args) + f"\n{self.indent}\n" ) class Picture(ShapeElement): @classmethod def from_shape( cls, slide_idx: int, shape_idx: int, shape: PPTXPicture, style: dict, text_frame: TextFrame, config: Config, slide_area: float, level: int, ): img_path = pjoin( config.IMAGE_DIR, f"{shape.image.sha1}.{shape.image.ext}", ) if shape.image.ext == "wmf": img_path = img_path.replace(".wmf", ".jpg") if not pexists(img_path): wmf_to_images(shape.image.blob, img_path) elif shape.image.ext not in IMAGE_EXTENSIONS: raise ValueError(f"unsupported image type {shape.image.ext}") if not pexists(img_path): with open(img_path, "wb") as f: f.write(shape.image.blob) style["img_style"] = { "crop_bottom": shape.crop_bottom, "crop_top": shape.crop_top, "crop_left": shape.crop_left, "crop_right": shape.crop_right, } picture = cls( slide_idx, shape_idx, style, [img_path, shape.name, ""], text_frame, slide_area, level=level, ) return picture def build(self, slide: PPTXSlide): shape = slide.shapes.add_picture( self.img_path, **self.style["shape_bounds"], ) shape.name = self.data[1] dict_to_object(self.style["img_style"], shape.image) apply_fill(shape, self.style["fill"]) if self.style["line"] is not None: apply_fill(shape.line, self.style["line"]["fill"]) dict_to_object(self.style["line"], shape.line, exclude=["fill"]) dict_to_object(self.style["shape_bounds"], shape) if "rotation" in dir(shape): shape.rotation = self.style["rotation"] return shape @property def img_path(self): return self.data[0] @img_path.setter def img_path(self, img_path: str): self.data[0] = img_path @property def caption(self): return self.data[2] @caption.setter def caption(self, caption: str): self.data[2] = caption def to_html(self, style_args: StyleArg) -> str: if not style_args.show_image: return "" if not self.caption: raise ValueError( f"caption not found for picture {self.shape_idx} of slide {self.slide_idx}" ) return ( self.indent + f"{self.caption}" ) class FreeformShape(ShapeElement): """ Represents a FREEFORM shape. Internally, a freeform is a shape with custom geometry. This class demonstrates how you might capture that geometry and rebuild it. """ @classmethod def from_shape( cls, slide_idx: int, shape_idx: int, shape, # This will be the pptx.shapes.autoshape.Shape whose type is FREEFORM style: dict, text_frame: TextFrame, config: Config, slide_area: float, level: int, ): """ Captures relevant geometry information (e.g., point sets) from the existing freeform shape. In python-pptx, retrieving detailed vertex information from the shape can be tricky, so you might rely on custom extension attributes, or simply store bounding-box and minimal details. The 'data' dict is for your use. For demonstration, we assume we have some way to extract or store basic vertex info from `shape`. Not all details of a FREEFORM can easily be retrieved from python-pptx, so you may have to maintain that data separately as you create them. """ # Hypothetical way to store some geometry or bounding box: data = { "name": shape.name, "width": shape.width, "height": shape.height, "left": shape.left, "top": shape.top, # Possibly store a list of points if you have them: "points": [], # If you have a way to retrieve them "closed": True, # Whether to close the path } return cls( slide_idx, shape_idx, style, data, text_frame, slide_area, level=level, ) def build(self, slide: PPTXSlide): """ Recreates the freeform geometry on the slide using a FreeformBuilder. Note: If you loaded this shape from an existing slide, you may already have it in place. Typically, build() is used when exporting back to PPTX from your internal representation. If you don't need to reconstruct (because the shape already exists), you can simply no-op here. This is an example of how you'd do it if you needed to fully recreate geometry. """ # Retrieve your geometry data left = self.data["left"] top = self.data["top"] width = self.data["width"] height = self.data["height"] points = self.data["points"] closed = self.data["closed"] # Start the builder at the first point (or top-left, etc.). # This is completely up to you how you define your local coordinate system. if points: first_x, first_y = points[0] else: # Default to top-left if no data first_x, first_y = (0, 0) builder = slide.shapes.build_freeform(left + first_x, top + first_y) # Now add line segments for the rest of the points (if any). # This is an example usage: if len(points) > 1: # Skip the first point since we used it in build_freeform(...) above builder.add_line_segments(points[1:], close=closed) # Convert to a shape shape = builder.convert_to_shape() # Possibly apply local styling, rotation, lines, etc. shape.name = self.data["name"] apply_fill(shape, self.style.get("fill")) if self.style.get("line") is not None: apply_fill(shape.line, self.style["line"]["fill"]) dict_to_object(self.style["line"], shape.line, exclude=["fill"]) # If you have a bounding box in .style["shape_bounds"], apply it: if "shape_bounds" in self.style: dict_to_object(self.style["shape_bounds"], shape) if "rotation" in self.style: shape.rotation = self.style["rotation"] return shape def to_html(self, style_args: StyleArg) -> str: """ Returns HTML representation. This could be empty, or you could provide something like an path if you have a means to convert the freeform's geometry to an SVG path. For now, just pretend it has no textual content. """ # If you want to attempt an SVG path, you'd do it here. A minimal example: # return ( f"{self.indent}
" f"\n{self.indent} " f"\n{self.indent}
\n" ) class Placeholder(ShapeElement): @classmethod def from_shape( cls, slide_idx: int, shape_idx: int, shape: SlidePlaceholder, style: dict, text_frame: TextFrame, config: Config, slide_area: float, level: int, ): assert ( sum( [ shape.has_text_frame, shape.has_chart, shape.has_table, isinstance(shape, PlaceholderPicture), ] ) == 1 ), "placeholder should have only one type" if isinstance(shape, PlaceholderPicture): data = Picture.from_shape( slide_idx, shape_idx, shape, style, text_frame, config, slide_area, level, ) elif shape.has_text_frame: data = TextBox.from_shape( slide_idx, shape_idx, shape, style, text_frame, config, slide_area, level, ) else: raise ValueError(f"unsupported placeholder {shape.placeholder_type}") return data class GroupShape(ShapeElement): @classmethod def from_shape( cls, slide_idx: int, shape_idx: int, shape: PPTXGroupShape, style: dict, text_frame: TextFrame, config: Config, slide_area: float, level: int, ): data = [ ShapeElement.from_shape( slide_idx, (shape_idx + 1) * 100 + i, sub_shape, config, slide_area, level=level + 1, ) for i, sub_shape in enumerate(shape.shapes) ] for idx, shape_bounds in enumerate(parse_groupshape(shape)): data[idx].style["shape_bounds"] = shape_bounds return cls( slide_idx, shape_idx, style, data, text_frame, slide_area, level=level ) def build(self, slide: PPTXSlide): for shape in self.data: shape.build(slide) return slide def to_pptc(self): return "\n".join([shape.to_pptc() for shape in self.data]) def __iter__(self): for shape in self.data: if isinstance(shape, GroupShape): yield from shape else: yield shape def __eq__(self, __value: object) -> bool: if not isinstance(__value, GroupShape) or len(self.data) != len(__value.data): return False for shape1, shape2 in zip(self.data, __value.data): if isinstance(shape1, type(shape2)): return False return True def __repr__(self) -> str: return f"{self.__class__.__name__}: {self.data}" def to_html(self, style_args: StyleArg) -> str: return ( self.indent + f"
\n" + "\n".join([shape.to_html(style_args) for shape in self.data]) + "\n" + self.indent + "
\n" ) class FreeShape(ShapeElement): @classmethod def from_shape( cls, slide_idx: int, shape_idx: int, shape: PPTXAutoShape, style: dict, text_frame: TextFrame, config: Config, slide_area: float, level: int, ): data = { "shape_type": shape.auto_shape_type.real, "svg_tag": str(shape.auto_shape_type).split()[0].lower(), } return cls( slide_idx, shape_idx, style, data, text_frame, slide_area, level=level ) def to_html(self, style_args: StyleArg) -> str: textframe = self.text_frame.to_html(style_args) if not textframe: return "" return ( f"{self.indent}
" + f"\n{textframe}" + f"\n{self.indent}
" ) class Connector(ShapeElement): @classmethod def from_shape( cls, slide_idx: int, shape_idx: int, shape: PPTXConnector, style: dict, text_frame: TextFrame, config: Config, slide_area: float, level: int, ): """ Convert a connector to a freeform shape. """ return FreeShape( slide_idx, shape_idx, style, {"shape_type": "connector", "svg_tag": "connector"}, text_frame, slide_area, level, ) class Table(ShapeElement): @classmethod def from_shape( cls, slide_idx: int, shape_idx: int, shape: TablePlaceholder, # or the actual shape holding the table style: dict, text_frame: TextFrame, config: Config, slide_area: float, level: int, ): """ Extract table data (rows, columns, text in each cell, etc.) from the table shape. """ pptx_table = shape.table # Adjust as needed if you'll need shape.table differently # Gather all cell text in a list-of-lists content = [] for row in pptx_table.rows: row_cells = [] for cell in row.cells: row_cells.append(cell.text) content.append(row_cells) data = { "rows": len(pptx_table.rows), "cols": len(pptx_table.columns), "content": content, } return cls( slide_idx, shape_idx, style, data, text_frame, # Typically unused for tables, but included for consistency slide_area, level=level, ) def build(self, slide: PPTXSlide): """ Rebuild this table on a pptx slide. """ # Use shape bounds from style if available table_shape = slide.shapes.add_table( self.data["rows"], self.data["cols"], **self.style["shape_bounds"] ) pptx_table = table_shape.table # Populate text in each cell for r in range(self.data["rows"]): for c in range(self.data["cols"]): pptx_table.cell(r, c).text = self.data["content"][r][c] # Apply additional styling if desired (fill, borders, etc.) # For example: # apply_fill(table_shape, self.style["fill"]) # dict_to_object(self.style["shape_bounds"], table_shape, exclude=...) return table_shape def to_html(self, style_args: StyleArg) -> str: """ Convert the table data to HTML, ensuring each row and cell is represented. """ # If there’s no content at all, return "" if not self.data["content"]: return "" rows_html = [] for row_cells in self.data["content"]: # If a row is empty, skip it (or handle however you like) if not row_cells: continue # Build each cell cells_html = "".join( f"{(cell_text or '').strip()}" for cell_text in row_cells ) rows_html.append(f"{cells_html}") # If after filtering empty rows we have nothing, return empty if not rows_html: return "" table_html = f"{self.indent}\n" table_html += "\n".join(rows_html) table_html += f"\n{self.indent}\n" return table_html class SlidePage: """ A class to represent a slide page in a presentation. """ def __init__( self, shapes: list[ShapeElement], slide_idx: int, real_idx: int, background_xml: str, slide_notes: str, slide_layout_name: str, slide_title: str, slide_width: int, slide_height: int, ): self.shapes = shapes self.slide_idx = slide_idx self.real_idx = real_idx self.background_xml = background_xml self.slide_notes = slide_notes self.slide_layout_name = slide_layout_name self.slide_title = slide_title self.slide_width = slide_width self.slide_height = slide_height groups_shapes_labels = [] for shape in self.shape_filter(GroupShape): for group_shape in groups_shapes_labels: if group_shape == shape: shape.group_label = group_shape.group_label continue groups_shapes_labels.append(shape) shape.group_label = f"group_{len(groups_shapes_labels)}" @classmethod def from_slide( cls, slide: PPTXSlide, slide_idx: int, real_idx: int, slide_width: int, slide_height: int, config: Config, ): """ Create a SlidePage from a PPTXSlide. Args: slide (PPTXSlide): The slide object. slide_idx (int): The index of the slide. real_idx (int): The real index of the slide. slide_width (int): The width of the slide. slide_height (int): The height of the slide. config (Config): The configuration object. Returns: SlidePage: The created SlidePage. """ shapes = [] for i, shape in enumerate(slide.shapes): try: if shape.visible: shape_element = ShapeElement.from_shape( slide_idx, i, shape, config, slide_width * slide_height ) shapes.append(shape_element) except: shape_element = ShapeElement.from_shape( slide_idx, i, shape, config, slide_width * slide_height ) background_xml = extract_fill(slide.background) slide_layout_name = slide.slide_layout.name if slide.slide_layout else None slide_title = slide.shapes.title.text if slide.shapes.title else None slide_notes = ( slide.notes_slide.notes_text_frame.text if slide.has_notes_slide and slide.notes_slide.notes_text_frame else None ) return cls( shapes, slide_idx, real_idx, background_xml, slide_notes, slide_layout_name, slide_title, slide_width, slide_height, ) def build(self, slide: PPTXSlide): for ph in slide.placeholders: ph.element.getparent().remove(ph.element) apply_fill(slide.background, self.background_xml) for shape in self.shapes: build_shape = shape.build(slide) for closure in shape.closures: try: closure.apply(build_shape) except: raise ValueError("Failed to apply closures to slides") return slide def shape_filter(self, shape_type: type, shapes: list[ShapeElement] = None): """ Filter shapes in the slide by type. Args: shape_type (type): The type of shapes to filter. shapes (list[ShapeElement]): The shapes to filter. Yields: ShapeElement: The filtered shapes. """ if shapes is None: shapes = self.shapes for shape in shapes: if isinstance(shape, shape_type): yield shape elif isinstance(shape, GroupShape): yield from self.shape_filter(shape_type, shape.data) def get_content_type(self): """ Get the content type of the slide. """ if len(list(self.shape_filter(Picture))) > 0: return "picture" return "text" def to_html(self, style_args: StyleArg = None, **kwargs) -> str: """ Represent the slide page in HTML. Args: style_args (StyleArg): The style arguments for HTML conversion. **kwargs: Additional arguments. Returns: str: The HTML representation of the slide page. """ if style_args is None: style_args = StyleArg(**kwargs) return "".join( [ "\n\n", (f"{self.slide_title}\n" if self.slide_title else ""), f'\n', "\n".join([shape.to_html(style_args) for shape in self.shapes]), "\n\n", ] ) def to_pptc(self): """ Represent the slide page in PPTC format. """ return "\n".join([shape.to_pptc() for shape in self.shapes]) def to_text(self, show_image: bool = False) -> str: """ Represent the slide page in text. """ text_content = "\n".join( [ shape.text_frame.text.strip() for shape in self.shapes if shape.text_frame.is_textframe ] ) if show_image: for image in self.shape_filter(Picture): if not image.caption: raise ValueError( f"caption not found for picture {image.shape_idx} of slide {image.slide_idx}" ) text_content += "\n" + "Image: " + image.caption return text_content @property def text_length(self): """ Get the length of the text in the slide page. """ return sum([len(shape.text_frame) for shape in self.shapes]) def __iter__(self): for shape in self.shapes: if isinstance(shape, GroupShape): yield from shape else: yield shape def __len__(self): return len(self.shapes) class Presentation: """ PPTAgent's representation of a presentation. Aiming at a more readable and editable interface. """ def __init__( self, slides: list[SlidePage], error_history: list[str], slide_width: float, slide_height: float, file_path: str, num_pages: int, ) -> None: """ Initialize the Presentation. """ self.slides = slides self.error_history = error_history self.slide_width = slide_width self.slide_height = slide_height self.num_pages = num_pages self.source_file = file_path self.prs = PPTXPre(self.source_file) self.layout_mapping = {layout.name: layout for layout in self.prs.slide_layouts} self.prs.core_properties.last_modified_by = "PPTAgent" @classmethod def from_file(cls, file_path: str, config: Config): """ Parse a Presentation from a file. """ prs = PPTXPre(file_path) slide_width = prs.slide_width slide_height = prs.slide_height slides = [] error_history = [] slide_idx = 0 layouts = [layout.name for layout in prs.slide_layouts] num_pages = len(prs.slides) for slide in prs.slides: if slide._element.get("show") == "0": continue # will not be printed to pdf slide_idx += 1 try: if slide.slide_layout.name not in layouts: raise ValueError( f"slide layout {slide.slide_layout.name} not found" ) slides.append( SlidePage.from_slide( slide, slide_idx - len(error_history), slide_idx, slide_width.pt, slide_height.pt, config, ) ) except Exception as e: error_history.append((slide_idx, str(e))) if config.DEBUG: print( f"Warning in slide {slide_idx} of {file_path}: {traceback.format_exc()}" ) return cls( slides, error_history, slide_width, slide_height, file_path, num_pages ) def save(self, file_path, layout_only=False): """ Save the presentation to a file. Args: file_path (str): The file path to save the presentation. layout_only (bool): Whether to save only the layout for slide clustering. """ self.clear_slides() for slide in self.slides: if layout_only: self.clear_images(slide.shapes) pptx_slide = self.build_slide(slide) if layout_only: self.clear_text(pptx_slide.shapes) self.prs.save(file_path) def build_slide(self, slide: SlidePage) -> PPTXSlide: """ Build a slide in the presentation. """ return slide.build( self.prs.slides.add_slide(self.layout_mapping[slide.slide_layout_name]) ) def clear_slides(self): """ Delete all slides from the presentation. """ while len(self.prs.slides) != 0: rId = self.prs.slides._sldIdLst[0].rId self.prs.part.drop_rel(rId) del self.prs.slides._sldIdLst[0] def clear_images(self, shapes: list[ShapeElement]): for shape in shapes: if isinstance(shape, GroupShape): self.clear_images(shape.data) elif isinstance(shape, Picture): shape.img_path = "resource/pic_placeholder.png" def clear_text(self, shapes: list[BaseShape]): for shape in shapes: if isinstance(shape, PPTXGroupShape): self.clear_text(shape.shapes) elif shape.has_text_frame: for para in shape.text_frame.paragraphs: for run in para.runs: run.text = "a" * len(run.text) def to_text(self, show_image: bool = False) -> str: """ Represent the presentation in text. """ return "\n----\n".join( [ ( f"Slide {slide.slide_idx} of {len(self.prs.slides)}\n" + (f"Title:{slide.slide_title}\n" if slide.slide_title else "") + slide.to_text(show_image) ) for slide in self.slides ] ) def __len__(self): return len(self.slides) SHAPECAST: dict[int, ShapeElement] = { MSO_SHAPE_TYPE.AUTO_SHAPE: FreeShape, MSO_SHAPE_TYPE.PLACEHOLDER: Placeholder, MSO_SHAPE_TYPE.PICTURE: Picture, MSO_SHAPE_TYPE.GROUP: GroupShape, MSO_SHAPE_TYPE.TEXT_BOX: TextBox, MSO_SHAPE_TYPE.LINE: Connector, MSO_SHAPE_TYPE.TABLE: Table, MSO_SHAPE_TYPE.FREEFORM: FreeformShape, } if __name__ == "__main__": from copy import deepcopy from glob import glob config = Config("/tmp") presentation = deepcopy( Presentation.from_file("runs/pptx/cip_default_template/source.pptx", config) ).save("./test.pptx") for pptx in glob("data/*/pptx/*/source.pptx"): presentation = deepcopy(Presentation.from_file(pptx, config)) for slide in presentation.slides: print(slide.to_html(show_image=False)) print("\033c", end="")