Combining Shinkai tools : from PowerPoint to audio

# /// script
# dependencies = [
#   "requests",
#   "python-pptx",
#   "pytesseract",
#   "pillow",
# ]
# ///

from typing import Optional, List
import os
import requests
import re
import shutil
from pptx import Presentation
from pptx.enum.shapes import MSO_SHAPE_TYPE
import pytesseract
from PIL import Image
import io
from shinkai_local_support import get_home_path
from shinkai_local_tools import shinkai_llm_prompt_processor, eleven_labs_text_to_speech

class CONFIG:
    tesseract_path: str
    generate_audio: str  # "yes" or "no"

class INPUTS:
    file_path: str
    additional_lesson_generation_instructions: Optional[str] = "none"

class OUTPUT:
    content_of_the_presentation: Optional[List[str]]
    status: str
    message: Optional[str]
    lesson_about_the_presentation: Optional[str]
    audio_file: Optional[str]

def extract_text_from_text_frame(text_frame) -> str:
    return ' '.join([run.text for paragraph in text_frame.paragraphs for run in paragraph.runs if run.text])

def extract_text_from_table(table) -> str:
    cell_texts = []
    for row in table.rows:
        for cell in row.cells:
            cell_texts.append(extract_text_from_text_frame(cell.text_frame))
    return ' | '.join(cell_texts)

def extract_text_from_chart(chart) -> str:
    title = extract_text_from_text_frame(chart.chart_title.text_frame) if chart.has_title else ""
    x_axis = extract_text_from_text_frame(chart.category_axis.title.text_frame) if chart.category_axis.has_title else ""
    y_axis = extract_text_from_text_frame(chart.value_axis.title.text_frame) if chart.value_axis.has_title else ""
    return f"Title: {title}, X-Axis: {x_axis}, Y-Axis: {y_axis}"

def extract_text_from_shape(shape) -> List[str]:
    results = []
    
    if shape.has_text_frame:
        text = extract_text_from_text_frame(shape.text_frame)
        if text.strip():
            results.append(f"Text Shape: {text}")
    elif shape.has_table:
        table_text = extract_text_from_table(shape.table)
        if table_text.strip():
            results.append(f"Table: {table_text}")
    elif shape.has_chart:
        chart_text = extract_text_from_chart(shape.chart)
        if chart_text.replace("Title: , X-Axis: , Y-Axis: ", "").strip():
            results.append(f"Chart: {chart_text}")
    elif shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
        try:
            image_data = shape.image.blob
            image = Image.open(io.BytesIO(image_data))
            text = pytesseract.image_to_string(image)
            if text.strip():
                results.append(f"Image Text: {text.strip()}")
        except Exception as e:
            pass
    elif shape.shape_type == MSO_SHAPE_TYPE.GROUP:
        for sub_shape in shape.shapes:
            sub_texts = extract_text_from_shape(sub_shape)
            if sub_texts:
                results.extend(sub_texts)
    
    return results

def clean_special_characters(text: str) -> str:
    text = re.sub(r'\n+', ' ', text)
    text = re.sub(r'#+\s*', ' ', text)
    text = re.sub(r'\*+', ' ', text)
    text = re.sub(r'\s+', ' ', text)
    return text.strip()

def get_base_filename(file_path: str) -> str:
    """Extract the base filename without extension from a path"""
    base_name = os.path.basename(file_path)
    if '?' in base_name:
        base_name = base_name.split('?')[0]
    return os.path.splitext(base_name)[0]

async def _read_presentation(file_path: str, working_file_path: str) -> OUTPUT:
    try:
        if file_path.startswith('http://') or file_path.startswith('https://'):
            response = requests.get(file_path)
            with open(working_file_path, 'wb') as f:
                f.write(response.content)
        else:
            with open(file_path, 'rb') as f:
                with open(working_file_path, 'wb') as w:
                    w.write(f.read())
        o = OUTPUT()
        o.status = "success"
        return o
    except Exception as e:
        o = OUTPUT()
        o.status = "error"
        o.message = f"Failed to read presentation: {str(e)}"
        return o

async def _retrieve_presentation(working_file_path: str) -> OUTPUT:
    if not os.path.exists(working_file_path):
        o = OUTPUT()
        o.status = "error"
        o.message = "No presentation file loaded."
        return o
    try:
        prs = Presentation(working_file_path)
        text_content = []
        for i, slide in enumerate(prs.slides, start=1):
            slide_content = []
            for shape in slide.shapes:
                shape_texts = extract_text_from_shape(shape)
                if shape_texts:
                    slide_content.extend(shape_texts)
            
            if slide_content:
                text_content.append(f"Slide {i}")
                text_content.extend(slide_content)
        
        o = OUTPUT()
        o.content_of_the_presentation = text_content
        o.status = "success"
        return o
    except Exception as e:
        o = OUTPUT()
        o.status = "error"
        o.message = f"Failed to process presentation: {str(e)}"
        return o

def validate_config(config: CONFIG) -> List[str]:
    """
    Validate configuration flags and dependencies.
    Returns a list of error messages if any issues are found.
    """
    errors = []
    # Validate tesseract_path
    if not config.tesseract_path:
        errors.append("Tesseract path is not provided.")
    elif not os.path.isfile(config.tesseract_path):
        errors.append(f"Tesseract path does not point to a file: {config.tesseract_path}")
    elif not os.access(config.tesseract_path, os.X_OK):
        errors.append(f"Tesseract executable is not executable: {config.tesseract_path}")
    
    # Validate generate_audio
    if config.generate_audio.lower() not in ["yes", "no"]:
        errors.append(f"Invalid config value for generate_audio: {config.generate_audio}. Must be 'yes' or 'no'.")
    
    return errors

async def run(config: CONFIG, inputs: INPUTS) -> OUTPUT:
    # Perform configuration validation
    errors = validate_config(config)
    if errors:
        o = OUTPUT()
        o.status = "error"
        o.message = "Configuration errors: " + "; ".join(errors)
        return o

    # Set Tesseract path after validation
    pytesseract.pytesseract.tesseract_cmd = config.tesseract_path

    home_path = await get_home_path()
    working_file_path = os.path.join(home_path, 'working.pptx')

    if not inputs.file_path:
        o = OUTPUT()
        o.status = "error"
        o.message = "No file path provided"
        return o

    read_result = await _read_presentation(inputs.file_path, working_file_path)
    if read_result.status == "error":
        return read_result

    process_result = await _retrieve_presentation(working_file_path)
    if process_result.status == "error":
        return process_result

    slides_content = process_result.content_of_the_presentation or []
    if not slides_content:
        o = OUTPUT()
        o.status = "warning"
        o.message = "No text content found in the presentation"
        o.content_of_the_presentation = []
        return o

    # Step 2: Formulate the prompt for the LLM
    prompt = (
        "<personality>"
        "You are a domain expert teacher extremely good at creating university level educational material."
        "</personality>"
        "<task>"
        "Create the text for an audio lesson of the following content extracted from a PowerPoint."
        "</task>"
        "<context>"
        "The content comes from text extraction and OCR from a PowerPoint, and is provided shape by shape and slide by slide."
        "Because of this the content form each slide might be a bit disorganised or sparse. You need to take your time step-by-step to reconnect the different pieces of content and understand how they fit together."
        "This content might also contain special characters coming from the text extraction formatting. Make sure to handle these special characters gracefully, they shouldn't appear in the text for an audio lesson."
        "</context>"
        "<lesson instructions>"
        "Do your best to understand in detailed the content of each slide, taking into consideration that it might be a bit disorganised due to the text extraction process."
        "The lesson should be very detailed and precise, and go over absolutely all the content in an organised manner. Be sure to use the entirety of the content for the lesson."
        "The lesson should be clear and engaging."
        "Make sure to introduce it when you move on to a new (sub)topic, so that the listener easily follow along."
        "</lesson instructions>"
        "<additional_instructions>"
        f"{inputs.additional_lesson_generation_instructions}"
        "</additional_instructions>"
        "<format instructions>"
        "Ensure the output is in one continuous paragraph without any special formatting or extra characters. Do not use and \ n formatting, just make it one long endless paragraph. It should be flowing text. You can still include sections in it but present them orally, not with special formatting."
        "The text must flow. Do not use any formatting, but just plain text."
        "</format instructions>"
        "<content>"
        "Here is the content to use for the lesson: "
        f"{' '.join(slides_content)}"
        "</content>"
    )

    # Step 3: Use the LLM to generate the audio lesson text
    llm_response = await shinkai_llm_prompt_processor({"prompt": prompt, "format": "text"})
    generated_text = llm_response['message']
    
    # Step 4: Clean any special characters from the generated text
    cleaned_text = clean_special_characters(generated_text)

    # Step 5: Convert the lesson text to audio if configured to do so
    audio_file_path = None
    if config.generate_audio.lower() == "yes":
        try:
            # Generate the audio with the TTS function
            tts_response = await eleven_labs_text_to_speech({"text": cleaned_text})
            generated_audio_path = tts_response['audio_file']
            
            # Get the base filename from the input file path and create the desired output path
            base_filename = get_base_filename(inputs.file_path)
            desired_audio_path = os.path.join(home_path, f"{base_filename}.mp3")
            
            # Rename the generated audio file to match the presentation name
            if os.path.exists(generated_audio_path):
                # Check if the destination file exists and remove it if it does
                if os.path.exists(desired_audio_path):
                    os.remove(desired_audio_path)
                # Copy the generated file to the desired location with the new name
                shutil.copy2(generated_audio_path, desired_audio_path)
                # Remove the original generated file
                os.remove(generated_audio_path)
                audio_file_path = desired_audio_path
            else:
                audio_file_path = generated_audio_path  # Fallback to the original path if something went wrong
        except Exception as e:
            o = OUTPUT()
            o.status = "error"
            o.message = f"Failed to generate or rename audio: {str(e)}"
            return o

    output = OUTPUT()
    output.content_of_the_presentation = slides_content
    output.lesson_about_the_presentation = cleaned_text
    output.audio_file = audio_file_path
    output.status = "success"
    return output