quicktools-atom 0.7.1__tar.gz → 0.7.3__tar.gz

{quicktools_atom-0.7.1 → quicktools_atom-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quicktools-atom
-Version: 0.7.1
+Version: 0.7.3
 Summary: Math, text, presentation, audio, video, and file utilities by AtomDev Studios
 Author-email: Samuel Peprah <windscribe.samuel@gmail.com>
 Project-URL: Homepage, https://github.com/Samuel-Peprah-cmd/quicktools
@@ -205,5 +205,5 @@ PostgreSQL • SQLite • Git • GitHub • Cloudflare • Docker
 
 
 
-\_\_version\_\_ = "0.7.0"
+\_\_version\_\_ = "0.7.3"
 

{quicktools_atom-0.7.1 → quicktools_atom-0.7.3}/README.md

@@ -182,5 +182,5 @@ PostgreSQL • SQLite • Git • GitHub • Cloudflare • Docker
 
 
 
-\_\_version\_\_ = "0.7.0"
+\_\_version\_\_ = "0.7.3"
 

{quicktools_atom-0.7.1 → quicktools_atom-0.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quicktools-atom"
-version = "0.7.1"
+version = "0.7.3"
 description = "Math, text, presentation, audio, video, and file utilities by AtomDev Studios"
 readme = "README.md"
 requires-python = ">=3.9"

{quicktools_atom-0.7.1 → quicktools_atom-0.7.3}/src/quicktools/__init__.py

@@ -92,4 +92,4 @@ PostgreSQL • SQLite • Git • GitHub • Cloudflare • Docker
 - `videotools` — video transcription, frame extraction, speaker diarization to Word scripts
 """
 
-__version__ = "0.7.0"
+__version__ = "0.7.3"

{quicktools_atom-0.7.1 → quicktools_atom-0.7.3}/src/quicktools/audiotools.py

@@ -75,11 +75,39 @@ def save_transcript_as_srt(segments: list[dict], output_path: str) -> None:
 
 # --- NEW DIARIZATION AND STYLING FEATURES ---
 
+def _load_waveform_via_av(path: str, target_sr: int = 16000):
+    """Decode any audio/video file into a mono waveform tensor using PyAV — bypassing
+    pyannote's own (fragile, Windows-unfriendly) torchcodec-based audio loader entirely."""
+    import av
+    import torch
+    import numpy as np
+
+    container = av.open(path)
+    resampler = av.AudioResampler(format="s16", layout="mono", rate=target_sr)
+    audio_stream = container.streams.audio[0]
+
+    chunks = []
+    for frame in container.decode(audio_stream):
+        for resampled in resampler.resample(frame):
+            chunks.append(resampled.to_ndarray())
+    container.close()
+
+    if not chunks:
+        raise RuntimeError(f"No audio could be decoded from '{path}'")
+
+    audio = np.concatenate(chunks, axis=1).astype(np.float32) / 32768.0  # int16 -> [-1, 1]
+    waveform = torch.from_numpy(audio)  # shape: (1, num_samples) since layout="mono"
+    return waveform, target_sr
+
+
 def transcribe_with_speakers(path: str, hf_token: str, model_size: str = "base") -> list[dict]:
-    """
-    Transcribes audio and aligns the text with Speaker IDs using Pyannote.
+    """Transcribe audio and label each segment with which speaker said it (speaker diarization).
     Returns a list of dicts: [{"start": 0.0, "end": 5.0, "speaker": "Speaker 00", "text": "Hello"}]
-    Requires a Hugging Face token with access to pyannote/speaker-diarization-3.1.
+
+    Requires:
+    - pip install pyannote.audio
+    - A free Hugging Face account + access token (huggingface.co/settings/tokens)
+    - Accepting the model terms at huggingface.co/pyannote/speaker-diarization-3.1
     """
     try:
         from pyannote.audio import Pipeline
@@ -88,38 +116,30 @@ def transcribe_with_speakers(path: str, hf_token: str, model_size: str = "base")
             "Speaker diarization requires pyannote.audio. Install it with: pip install pyannote.audio"
         )
 
-    print("1/3: Analyzing voice biometrics (Diarization)...")
-    pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization-3.1", use_auth_token=hf_token)
-    diarization = pipeline(path)
+    waveform, sample_rate = _load_waveform_via_av(path)
+
+    pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization-3.1", token=hf_token)
+    diarization = pipeline({"waveform": waveform, "sample_rate": sample_rate})
 
-    print("2/3: Transcribing audio text...")
     model = _load_model(model_size)
     segments, _ = model.transcribe(path)
 
-    print("3/3: Aligning text to speakers...")
     transcript_data = []
-    
     for segment in segments:
-        # Find the midpoint of the spoken phrase
-        segment_midpoint = (segment.start + segment.end) / 2
-        
-        # Check which speaker was talking at that exact millisecond
+        midpoint = (segment.start + segment.end) / 2
         current_speaker = "Unknown"
         for turn, _, speaker in diarization.itertracks(yield_label=True):
-            if turn.start <= segment_midpoint <= turn.end:
+            if turn.start <= midpoint <= turn.end:
                 current_speaker = speaker
                 break
-                
         transcript_data.append({
             "start": segment.start,
             "end": segment.end,
             "speaker": current_speaker.replace("SPEAKER_", "Speaker "),
-            "text": segment.text.strip()
+            "text": segment.text.strip(),
         })
-        
     return transcript_data
 
-
 def save_transcript_to_docx(transcript_data: list[dict], output_path: str) -> None:
     """
     Takes speaker-mapped transcript data and generates a beautifully styled Word document.

quicktools_atom-0.7.3/src/quicktools/presentationtools.py

@@ -0,0 +1,294 @@
+"""PowerPoint utilities: reading, creating .pptx files, and content-based conversion
+to/from Word documents and PDFs — with styled themes and image placement.
+
+Note on conversions: Word docs, PDFs, and PowerPoint decks use fundamentally different
+document models (flowing paragraphs vs. discrete slides). These functions preserve and
+reorganize the actual text content and images sensibly into the new format — they do not
+attempt to replicate exact visual layout, because no such 1:1 mapping exists between formats.
+
+Themes are applied entirely in code (background/title/accent colors) — no external
+template files or network downloads are required.
+"""
+import io
+import random
+from pptx import Presentation
+from pptx.util import Inches, Pt
+from pptx.dml.color import RGBColor
+from pptx.enum.shapes import MSO_SHAPE_TYPE
+
+# Each theme is a self-contained color palette applied entirely in code.
+THEMES = [
+    {"name": "Ocean Blue", "background": RGBColor(0x0B, 0x2A, 0x4A), "title": RGBColor(0xFF, 0xFF, 0xFF), "accent": RGBColor(0x9C, 0xD3, 0xFF)},
+    {"name": "Sunset Orange", "background": RGBColor(0x3A, 0x1A, 0x0A), "title": RGBColor(0xFF, 0xD9, 0xA0), "accent": RGBColor(0xFF, 0xFF, 0xFF)},
+    {"name": "Forest Green", "background": RGBColor(0x0E, 0x2E, 0x1D), "title": RGBColor(0xFF, 0xFF, 0xFF), "accent": RGBColor(0xA8, 0xE6, 0xB8)},
+    {"name": "Monochrome", "background": RGBColor(0x1A, 0x1A, 0x1A), "title": RGBColor(0xFF, 0xFF, 0xFF), "accent": RGBColor(0xCC, 0xCC, 0xCC)},
+    {"name": "Soft Light", "background": RGBColor(0xF5, 0xF5, 0xF0), "title": RGBColor(0x22, 0x22, 0x22), "accent": RGBColor(0x44, 0x44, 0x44)},
+]
+
+class Theme:
+    """Pre-defined theme constants for easy IDE auto-completion."""
+    OCEAN_BLUE = "Ocean Blue"
+    SUNSET_ORANGE = "Sunset Orange"
+    FOREST_GREEN = "Forest Green"
+    MONOCHROME = "Monochrome"
+    SOFT_LIGHT = "Soft Light"
+
+
+def _pick_theme(theme_name: str | None = None) -> dict:
+    """Return a theme dict by name, or a random one if no name is given."""
+    if theme_name:
+        for t in THEMES:
+            if t["name"].lower() == theme_name.lower():
+                return t
+        raise ValueError(f"Unknown theme '{theme_name}'. Available: {[t['name'] for t in THEMES]}")
+    return random.choice(THEMES)
+
+
+def _apply_background(slide, theme: dict) -> None:
+    """Fill a slide's background with the theme's background color."""
+    fill = slide.background.fill
+    fill.solid()
+    fill.fore_color.rgb = theme["background"]
+
+
+def _add_slide_with_text(prs: Presentation, theme: dict, title: str, body_lines: list[str],
+                          image_path: str | None = None) -> None:
+    """Internal helper: add a themed slide with a title, bullet text, and an optional image."""
+    blank_layout = prs.slide_layouts[6]
+    slide = prs.slides.add_slide(blank_layout)
+    _apply_background(slide, theme)
+
+    has_image = image_path is not None
+    text_width = Inches(4.7) if has_image else Inches(9)
+
+    title_box = slide.shapes.add_textbox(Inches(0.5), Inches(0.3), text_width, Inches(1))
+    tf = title_box.text_frame
+    tf.word_wrap = True
+    tf.text = title
+    tf.paragraphs[0].font.size = Pt(28)
+    tf.paragraphs[0].font.bold = True
+    tf.paragraphs[0].font.color.rgb = theme["title"]
+
+    body_box = slide.shapes.add_textbox(Inches(0.5), Inches(1.5), text_width, Inches(5.3))
+    body_tf = body_box.text_frame
+    body_tf.word_wrap = True
+    for i, line in enumerate(body_lines):
+        p = body_tf.paragraphs[0] if i == 0 else body_tf.add_paragraph()
+        p.text = f"• {line}"
+        p.font.size = Pt(18)
+        p.font.color.rgb = theme["accent"]
+
+    if has_image:
+        slide.shapes.add_picture(image_path, Inches(5.5), Inches(1.5), width=Inches(4), height=Inches(4.5))
+
+
+def read_pptx_text(path: str) -> str:
+    """Extract all text from every slide in a .pptx file."""
+    prs = Presentation(path)
+    lines = []
+    for slide in prs.slides:
+        for shape in slide.shapes:
+            if shape.has_text_frame:
+                for paragraph in shape.text_frame.paragraphs:
+                    text = "".join(run.text for run in paragraph.runs)
+                    if text:
+                        lines.append(text)
+    return "\n".join(lines)
+
+
+def get_pptx_slide_count(path: str) -> int:
+    """Return the number of slides in a .pptx file."""
+    return len(Presentation(path).slides)
+
+
+def list_available_themes() -> list[str]:
+    """Return the names of all available built-in themes."""
+    return [t["name"] for t in THEMES]
+
+
+def create_pptx_from_text(text: str, output_path: str, theme_name: str | None = None) -> None:
+    """Create a themed .pptx file from text, splitting on blank lines into separate slides.
+    Each slide's first line becomes its title; remaining lines become bullet content.
+    theme_name picks a specific theme (see list_available_themes()); omit for a random one."""
+    theme = _pick_theme(theme_name)
+    prs = Presentation()
+    blocks = [b.strip() for b in text.split("\n\n") if b.strip()]
+    if not blocks:
+        blocks = [text]
+    for block in blocks:
+        lines = [l for l in block.split("\n") if l.strip()]
+        title = lines[0] if lines else "Untitled"
+        body = lines[1:] if len(lines) > 1 else []
+        _add_slide_with_text(prs, theme, title, body)
+    prs.save(output_path)
+
+
+def _looks_like_heading(paragraph) -> bool:
+    """Heuristic: is this docx paragraph likely meant as a section heading?
+    True Word heading styles always count. As a fallback (since many real documents never
+    use proper Word styles), a short, fully-bolded line with no trailing period is also
+    treated as a heading."""
+    style_name = paragraph.style.name.lower()
+    if style_name.startswith("heading") or style_name == "title":
+        return True
+    text = paragraph.text.strip()
+    if not text or len(text) > 60 or text.endswith((".", ",", ";")):
+        return False
+    runs = [r for r in paragraph.runs if r.text.strip()]
+    return bool(runs) and all(r.bold for r in runs)
+
+
+def _extract_paragraph_images(paragraph, doc) -> list[bytes]:
+    """Extract raw image bytes for any images embedded directly in this docx paragraph."""
+    from docx.oxml.ns import qn
+    images = []
+    for run in paragraph.runs:
+        for blip in run._element.findall(".//" + qn("a:blip")):
+            rId = blip.get(qn("r:embed"))
+            if rId and rId in doc.part.rels:
+                images.append(doc.part.rels[rId].target_part.blob)
+    return images
+
+
+def pptx_to_docx(path: str, output_path: str) -> None:
+    """Convert a .pptx file to .docx: each slide's title becomes a heading, its text becomes
+    paragraphs, and any picture on the slide is inserted into the document."""
+    from docx import Document
+    prs = Presentation(path)
+    doc = Document()
+    for i, slide in enumerate(prs.slides):
+        texts = []
+        image_blobs = []
+        for shape in slide.shapes:
+            if shape.has_text_frame:
+                for paragraph in shape.text_frame.paragraphs:
+                    line = "".join(run.text for run in paragraph.runs)
+                    if line:
+                        texts.append(line)
+            if shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
+                image_blobs.append(shape.image.blob)
+        if not texts and not image_blobs:
+            continue
+        if texts:
+            doc.add_heading(texts[0], level=1)
+            for line in texts[1:]:
+                doc.add_paragraph(line)
+        for blob in image_blobs:
+            doc.add_picture(io.BytesIO(blob), width=Inches(4))
+        if i < len(prs.slides) - 1:
+            doc.add_page_break()
+    doc.save(output_path)
+
+
+def docx_to_pptx(path: str, output_path: str, theme_name: str | None = None) -> None:
+    """Convert a .docx file to a themed .pptx: headings (or bolded short lines) start new
+    slides, normal paragraphs become bullet content, and any embedded image is placed
+    on its corresponding slide. theme_name picks a specific theme; omit for a random one."""
+    from docx import Document
+    import tempfile
+
+    doc = Document(path)
+    theme = _pick_theme(theme_name)
+    prs = Presentation()
+
+    current_title = None
+    current_body: list[str] = []
+    current_image: str | None = None
+
+    def flush():
+        if current_title is not None:
+            _add_slide_with_text(prs, theme, current_title, current_body, current_image)
+
+    for p in doc.paragraphs:
+        text = p.text.strip()
+        images = _extract_paragraph_images(p, doc)
+        image_path = None
+        if images:
+            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+            tmp.write(images[0])
+            tmp.close()
+            image_path = tmp.name
+
+        if not text and not image_path:
+            continue
+
+        if text and _looks_like_heading(p):
+            flush()
+            current_title = text
+            current_body = []
+            current_image = image_path
+        else:
+            if current_title is None:
+                current_title = text or "Untitled"
+            elif text:
+                current_body.append(text)
+            if image_path and current_image is None:
+                current_image = image_path
+    flush()
+
+    prs.save(output_path)
+
+
+def pdf_to_pptx(path: str, output_path: str, theme_name: str | None = None) -> None:
+    """Convert a PDF to a themed .pptx: each page's extracted text and first embedded
+    image (if any) are placed onto their own slide. theme_name picks a specific theme;
+    omit for a random one."""
+    from pypdf import PdfReader
+    import tempfile
+
+    reader = PdfReader(path)
+    theme = _pick_theme(theme_name)
+    prs = Presentation()
+
+    for i, page in enumerate(reader.pages):
+        text = page.extract_text() or ""
+        lines = [l for l in text.split("\n") if l.strip()]
+        title = lines[0] if lines else f"Page {i + 1}"
+        body = lines[1:] if len(lines) > 1 else []
+
+        image_path = None
+        try:
+            images = page.images
+            if len(images) > 0:
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+                images[0].image.save(tmp.name)
+                tmp.close()
+                image_path = tmp.name
+        except Exception:
+            image_path = None
+
+        _add_slide_with_text(prs, theme, title, body, image_path)
+
+    prs.save(output_path)
+
+
+def extract_pptx_notes(path: str) -> list[str]:
+    """Extract the speaker notes from every slide in a .pptx file."""
+    prs = Presentation(path)
+    notes = []
+    for slide in prs.slides:
+        if slide.has_notes_slide:
+            notes.append(slide.notes_slide.notes_text_frame.text)
+        else:
+            notes.append("")
+    return notes
+
+
+def merge_pptx_files(paths: list[str], output_path: str, theme_name: str | None = None) -> None:
+    """Merge multiple .pptx files' content into one themed deck, preserving slide order."""
+    theme = _pick_theme(theme_name)
+    prs = Presentation()
+    for path in paths:
+        source = Presentation(path)
+        for slide in source.slides:
+            texts = []
+            for shape in slide.shapes:
+                if shape.has_text_frame:
+                    for paragraph in shape.text_frame.paragraphs:
+                        line = "".join(run.text for run in paragraph.runs)
+                        if line:
+                            texts.append(line)
+            title = texts[0] if texts else "Untitled"
+            body = texts[1:] if len(texts) > 1 else []
+            _add_slide_with_text(prs, theme, title, body)
+    prs.save(output_path)

{quicktools_atom-0.7.1 → quicktools_atom-0.7.3}/src/quicktools_atom.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quicktools-atom
-Version: 0.7.1
+Version: 0.7.3
 Summary: Math, text, presentation, audio, video, and file utilities by AtomDev Studios
 Author-email: Samuel Peprah <windscribe.samuel@gmail.com>
 Project-URL: Homepage, https://github.com/Samuel-Peprah-cmd/quicktools
@@ -205,5 +205,5 @@ PostgreSQL • SQLite • Git • GitHub • Cloudflare • Docker
 
 
 
-\_\_version\_\_ = "0.7.0"
+\_\_version\_\_ = "0.7.3"
 

quicktools_atom-0.7.1/src/quicktools/presentationtools.py

@@ -1,249 +0,0 @@
-"""PowerPoint utilities: reading, creating .pptx files, and smart content-based conversion
-to/from Word documents and PDFs.
-
-This module features a Semantic Layout Engine: when converting from Word or text,
-it automatically detects Headings to create Slide Titles, formats normal text as 
-bullet points, and dynamically snaps images into professional slide layouts.
-"""
-import os
-import random
-import tempfile
-import urllib.request
-from pptx import Presentation
-from pptx.util import Inches, Pt
-
-CLOUD_THEMES = [
-    "https://raw.githubusercontent.com/Samuel-Peprah-cmd/quicktools/main/assets/themes/modern_blue.pptx",
-    "https://raw.githubusercontent.com/Samuel-Peprah-cmd/quicktools/main/assets/themes/dark_minimal.pptx",
-    "https://raw.githubusercontent.com/Samuel-Peprah-cmd/quicktools/main/assets/themes/creative_orange.pptx"
-]
-
-def _get_template_path(template_target: str | None) -> str | None:
-    """Internal helper: Resolves a template file, a local directory, or fetches a cloud theme."""
-    if not template_target:
-        return None
-        
-    # --- NEW: Cloud Fetching ---
-    if template_target.lower() == "random_cloud":
-        print("Fetching a random theme from the cloud...")
-        url = random.choice(CLOUD_THEMES)
-        try:
-            # Create a temporary file that deletes itself when the script finishes
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pptx")
-            urllib.request.urlretrieve(url, temp_file.name)
-            return temp_file.name
-        except Exception as e:
-            print(f"Warning: Could not fetch cloud theme ({e}). Falling back to blank template.")
-            return None
-
-    # --- Local File/Folder Logic ---
-    if os.path.isfile(template_target) and template_target.endswith('.pptx'):
-        return template_target
-        
-    if os.path.isdir(template_target):
-        templates = [os.path.join(template_target, f) for f in os.listdir(template_target) if f.endswith('.pptx')]
-        if templates:
-            return random.choice(templates)
-            
-    return None
-
-def read_pptx_text(path: str) -> str:
-    """Extract all text from every slide in a .pptx file."""
-    prs = Presentation(path)
-    lines = []
-    for slide in prs.slides:
-        for shape in slide.shapes:
-            if shape.has_text_frame:
-                for paragraph in shape.text_frame.paragraphs:
-                    text = "".join(run.text for run in paragraph.runs)
-                    if text:
-                        lines.append(text)
-    return "\n".join(lines)
-
-
-def get_pptx_slide_count(path: str) -> int:
-    """Return the number of slides in a .pptx file."""
-    return len(Presentation(path).slides)
-
-
-def create_smart_pptx(slide_data: list[dict], output_path: str, template_target: str | None = None) -> None:
-    """
-    Creates a formatted PowerPoint presentation from structured data.
-    slide_data format: [{"title": "Slide 1", "content": ["Point 1", "Point 2"], "image": "path.jpg"}]
-    
-    If template_target is a directory, a random .pptx theme from that directory is applied.
-    """
-    theme = _get_template_path(template_target)
-    prs = Presentation(theme) if theme else Presentation()
-
-    # Standard Layout indices: 0 = Title Slide, 1 = Title & Content, 8 = Picture with Caption
-    title_slide_layout = prs.slide_layouts[0]
-    
-    # Fallbacks in case the custom template is structured unusually
-    try:
-        content_slide_layout = prs.slide_layouts[1]
-    except IndexError:
-        content_slide_layout = prs.slide_layouts[0]
-
-    for i, slide_dict in enumerate(slide_data):
-        title = slide_dict.get("title", "Untitled Slide")
-        content = slide_dict.get("content", [])
-        image_path = slide_dict.get("image", None)
-
-        # Use Title Slide layout for the very first slide if it has no bullets
-        if i == 0 and not content and not image_path:
-            slide = prs.slides.add_slide(title_slide_layout)
-            if slide.shapes.title:
-                slide.shapes.title.text = title
-            if len(slide.placeholders) > 1:
-                slide.placeholders[1].text = "Generated by quicktools"
-            continue
-
-        # Create a standard slide
-        slide = prs.slides.add_slide(content_slide_layout)
-        
-        # Set Title
-        if slide.shapes.title:
-            slide.shapes.title.text = title
-        
-        # Set Bullet Points
-        if len(slide.placeholders) > 1:
-            body_shape = slide.placeholders[1]
-            tf = body_shape.text_frame
-            
-            for idx, point in enumerate(content):
-                p = tf.paragraphs[0] if idx == 0 else tf.add_paragraph()
-                p.text = point
-                p.font.size = Pt(20)
-
-            # Smart Image Placement Strategy
-            if image_path and os.path.exists(image_path):
-                # Shrink the text box to make room for the image on the right
-                body_shape.width = Inches(5)
-                
-                # Snap image to the right side of a standard 10x7.5 widescreen slide
-                left_position = Inches(5.5)
-                top_position = Inches(2)
-                image_height = Inches(4.5)
-                
-                slide.shapes.add_picture(image_path, left_position, top_position, height=image_height)
-
-    prs.save(output_path)
-
-
-def create_pptx_from_text(text: str, output_path: str, template_target: str | None = None) -> None:
-    """Create a .pptx file from text, splitting on blank lines into separate slides.
-    Routes to the smart layout engine."""
-    blocks = [b.strip() for b in text.split("\n\n") if b.strip()]
-    if not blocks:
-        blocks = [text]
-    
-    slide_data = []
-    for block in blocks:
-        lines = [l for l in block.split("\n") if l.strip()]
-        title = lines[0] if lines else "Untitled"
-        body = lines[1:] if len(lines) > 1 else []
-        slide_data.append({"title": title, "content": body})
-        
-    create_smart_pptx(slide_data, output_path, template_target)
-
-
-def pptx_to_docx(path: str, output_path: str) -> None:
-    """Convert a .pptx file to .docx, using each slide's text as a section."""
-    from docx import Document
-    prs = Presentation(path)
-    doc = Document()
-    for i, slide in enumerate(prs.slides):
-        texts = []
-        for shape in slide.shapes:
-            if shape.has_text_frame:
-                for paragraph in shape.text_frame.paragraphs:
-                    line = "".join(run.text for run in paragraph.runs)
-                    if line:
-                        texts.append(line)
-        if not texts:
-            continue
-        doc.add_heading(texts[0], level=1)
-        for line in texts[1:]:
-            doc.add_paragraph(line)
-        if i < len(prs.slides) - 1:
-            doc.add_page_break()
-    doc.save(output_path)
-
-
-def docx_to_pptx(path: str, output_path: str, template_target: str | None = None) -> None:
-    """Convert a .docx file to .pptx using semantic parsing.
-    Headings become Slide Titles. Normal text becomes bullet points."""
-    from docx import Document
-    doc = Document(path)
-    slide_data = []
-    current_slide = None
-
-    for p in doc.paragraphs:
-        text = p.text.strip()
-        if not text:
-            continue
-        
-        is_heading = p.style.name.lower().startswith("heading") or p.style.name.lower() == "title"
-        
-        if is_heading:
-            if current_slide:
-                slide_data.append(current_slide)
-            current_slide = {"title": text, "content": []}
-        else:
-            if current_slide is None:
-                current_slide = {"title": text, "content": []}
-            else:
-                current_slide["content"].append(text)
-
-    if current_slide:
-        slide_data.append(current_slide)
-
-    create_smart_pptx(slide_data, output_path, template_target)
-
-
-def pdf_to_pptx(path: str, output_path: str, template_target: str | None = None) -> None:
-    """Convert a PDF to .pptx, placing each PDF page's extracted text onto its own slide."""
-    from pypdf import PdfReader
-    reader = PdfReader(path)
-    slide_data = []
-    
-    for i, page in enumerate(reader.pages):
-        text = page.extract_text() or ""
-        lines = [l for l in text.split("\n") if l.strip()]
-        title = f"Page {i + 1}"
-        slide_data.append({"title": title, "content": lines})
-        
-    create_smart_pptx(slide_data, output_path, template_target)
-
-
-def extract_pptx_notes(path: str) -> list[str]:
-    """Extract the speaker notes from every slide in a .pptx file."""
-    prs = Presentation(path)
-    notes = []
-    for slide in prs.slides:
-        if slide.has_notes_slide:
-            notes.append(slide.notes_slide.notes_text_frame.text)
-        else:
-            notes.append("")
-    return notes
-
-
-def merge_pptx_files(paths: list[str], output_path: str) -> None:
-    """Merge multiple .pptx files' content into one, preserving slide order across files."""
-    slide_data = []
-    for path in paths:
-        source = Presentation(path)
-        for slide in source.slides:
-            texts = []
-            for shape in slide.shapes:
-                if shape.has_text_frame:
-                    for paragraph in shape.text_frame.paragraphs:
-                        line = "".join(run.text for run in paragraph.runs)
-                        if line:
-                            texts.append(line)
-            title = texts[0] if texts else "Untitled"
-            body = texts[1:] if len(texts) > 1 else []
-            slide_data.append({"title": title, "content": body})
-            
-    create_smart_pptx(slide_data, output_path)