Python-PPTX

from pptx import Presentation

from pptx.util import Inches, Cm, Pt
from pptx.enum.text import PP_PARAGRAPH_ALIGNMENT
from pptx.enum.shapes import MSO_SHAPE
from pptx.chart.data import CategoryChartData
from pptx.enum.chart import XL_CHART_TYPE
from pptx.dml.color import RGBColor

from pptx import Presentation
from pptx.util import Inches
from pptx.enum.shapes import MSO_SHAPE

# Create a new presentation
prs = Presentation()

# Add a slide with title and content layout
slide_layout = prs.slide_layouts[1]  # Title and Content layout
slide = prs.slides.add_slide(slide_layout)

# Add title and content
title = slide.shapes.title
title.text = "My Presentation Title"

content = slide.placeholders[1]  # Content placeholder
tf = content.text_frame
tf.text = "This is the first bullet point"

# Add another bullet point
p = tf.add_paragraph()
p.text = "This is the second bullet point"
p.level = 1

# Add a shape
left = top = width = height = Inches(1)
shape = slide.shapes.add_shape(
    MSO_SHAPE.RECTANGLE, left, top, width, height
)
shape.text = "This is a text box"

# Save the presentation
prs.save('my-presentation.pptx')

from typing import IO
from pptx import presentation

def Presentation(pptx: str | IO[bytes] | None = None) -> presentation.Presentation:
    """
    Create or load a presentation.
    
    Parameters:
    - pptx: str | IO[bytes] | None, path to .pptx file, file-like object, or None for new presentation
    
    Returns:
    presentation.Presentation object
    """

class Presentation:
    """Main presentation object containing slides and configuration."""
    slides: Slides
    slide_layouts: SlideLayouts  
    slide_masters: SlideMasters
    slide_width: int  # in EMU
    slide_height: int  # in EMU
    core_properties: CoreProperties
    
    def save(self, file):
        """Save presentation to file path or file-like object."""

class Slides:
    """Collection of slides in a presentation."""
    def add_slide(self, slide_layout): ...
    def __getitem__(self, index): ...
    def __len__(self): ...

class Slide:
    """Individual slide with shapes and properties."""
    shapes: SlideShapes
    slide_layout: SlideLayout
    notes_slide: NotesSlide
    
    @property
    def name(self): ...

class SlideShapes:
    """Collection of shapes on a slide."""
    def add_textbox(self, left, top, width, height): ...
    def add_picture(self, image_file, left, top, width=None, height=None): ...
    def add_shape(self, autoshape_type, left, top, width, height): ...
    def add_table(self, rows, cols, left, top, width, height): ...
    def add_chart(self, chart_type, x, y, cx, cy, chart_data): ...
    
class BaseShape:
    """Base class for all shapes."""
    name: str
    shape_type: MSO_SHAPE_TYPE
    left: int  # position in EMU
    top: int
    width: int
    height: int

class TextFrame:
    """Container for text content."""
    paragraphs: list
    text: str
    def add_paragraph(self): ...
    
class Font:
    """Text formatting properties."""
    name: str
    size: Pt
    bold: bool
    italic: bool
    color: ColorFormat
    underline: bool

class CategoryChartData:
    """Data container for category-based charts."""
    def add_series(self, name, values=None): ...
    
class Chart:
    """Chart object with plot area, legend, and axes."""
    chart_type: XL_CHART_TYPE
    plots: list
    legend: Legend
    value_axis: ValueAxis
    category_axis: CategoryAxis

class Table:
    """Table with rows and columns."""
    rows: _RowCollection
    columns: _ColumnCollection
    def cell(self, row_idx, col_idx): ...
    
class _Cell:
    """Individual table cell."""
    text: str
    text_frame: TextFrame
    fill: FillFormat
    def merge(self, other_cell): ...

class RGBColor:
    """RGB color specification."""
    def __init__(self, r, g, b): ...
    
class ColorFormat:
    """Color formatting with type-specific properties."""
    rgb: RGBColor
    theme_color: MSO_THEME_COLOR_INDEX
    brightness: float
    
class FillFormat:
    """Fill formatting for shapes and text."""
    solid(): ...
    gradient(): ...
    patterned(): ...

def Inches(inches): 
    """Create Length from inches measurement."""
def Cm(cm):
    """Create Length from centimeters measurement."""  
def Pt(points):
    """Create Length from points measurement."""
def Mm(mm):
    """Create Length from millimeters measurement."""
    
class Length:
    """Length measurement with unit conversion."""
    inches: float
    cm: float
    pt: float
    mm: float

class PythonPptxError(Exception):
    """Base exception for python-pptx operations."""

class PackageNotFoundError(PythonPptxError):
    """Raised when .pptx file cannot be found."""
    
class InvalidXmlError(PythonPptxError):
    """Raised when XML content is invalid."""