Upload folder using huggingface_hub

README.md

@@ -10,11 +10,16 @@ sdk_version: 5.13.1
 [![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
+[![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/rogeliorichman/AI_Script_Generator)
 
 > Transform transcripts and PDFs into timed, structured teaching scripts using AI
 
 AI Script Generator is an advanced AI system that converts PDF transcripts, raw text, and conversational content into well-structured teaching scripts. It seamlessly processes inputs, extracting and analyzing the content to create organized, pedagogically sound scripts with time markers. Designed for educators, students, content creators, and anyone looking to transform information into clear explanations.
 
+## 🔗 Live Demo
+
+Try it out: [AI Script Generator on Hugging Face Spaces](https://huggingface.co/spaces/rogeliorichman/AI_Script_Generator)
+
 ## ✨ Features
 
 - 🤖 PDF transcript and raw text processing
@@ -23,6 +28,8 @@ AI Script Generator is an advanced AI system that converts PDF transcripts, raw
 - 🔄 Coherent topic organization
 - 🔌 Support for multiple AI providers (Gemini/OpenAI)
 - ⏱️ Time-marked sections for pacing
+- 🌐 Multilingual interface (English/Spanish) with flag selector
+- 🌍 Generation in ANY language through the guiding prompt (not limited to UI languages)
 
 ## Output Format
 
@@ -220,8 +227,16 @@ Project Link: [https://github.com/RogelioRichmanAstronaut/AI-Script-Generator](h
 - [ ] Support for multiple output formats (PDF, PPTX)
 - [ ] Interactive elements generation
 - [ ] Custom templating system
-- [ ] Multi-language support
+- [ ] Copy to clipboard button for generated content
+- [x] Multilingual capabilities
+  - [x] Content generation in any language via guiding prompt
+  - [x] UI language support
+    - [x] English
+    - [x] Spanish
+    - [ ] French
+    - [ ] German
 - [ ] Integration with LMS platforms
+- [x] Timestamp toggle - ability to show/hide time markers in the output text
 
 ---
 

src/app.py

@@ -1,5 +1,6 @@
 import os
 import gradio as gr
+import re
 from dotenv import load_dotenv
 from src.core.transformer import TranscriptTransformer
 from src.utils.pdf_processor import PDFProcessor
@@ -7,12 +8,73 @@ from src.utils.text_processor import TextProcessor
 
 load_dotenv()
 
+# Translations dictionary for UI elements
+TRANSLATIONS = {
+    "en": {
+        "title": "AI Script Generator",
+        "subtitle": "Transform transcripts and PDFs into timed, structured teaching scripts using AI",
+        "input_type_label": "Input Type",
+        "input_type_options": ["PDF", "Raw Text"],
+        "upload_pdf_label": "Upload Transcript (PDF)",
+        "paste_text_label": "Paste Transcript Text",
+        "paste_text_placeholder": "Paste your transcript text here...",
+        "guiding_prompt_label": "Guiding Prompt (Optional)",
+        "guiding_prompt_placeholder": "Additional instructions to customize the output. Examples: 'Use a more informal tone', 'Focus only on section X', 'Generate the content in Spanish', 'Include more practical programming examples', etc.",
+        "guiding_prompt_info": "The Guiding Prompt allows you to provide specific instructions to modify the generated content, like output/desired LANGUAGE. You can use it to change the tone, style, focus ONLY on specific sections of the text, specify the output language (e.g., 'Generate in Spanish/French/German'), or give any other instruction that helps personalize the final result.",
+        "duration_label": "Target Lecture Duration (minutes)",
+        "examples_label": "Include Practical Examples",
+        "thinking_model_label": "Use Experimental Thinking Model (Gemini Only)",
+        "submit_button": "Transform Transcript",
+        "output_label": "Generated Teaching Transcript",
+        "error_no_pdf": "Error: No PDF file uploaded",
+        "error_no_text": "Error: No text provided",
+        "error_prefix": "Error processing transcript: ",
+        "language_selector": "Language / Idioma",
+        "show_timestamps": "Show Timestamps",
+        "hide_timestamps": "Hide Timestamps"
+    },
+    "es": {
+        "title": "Generador de Guiones IA",
+        "subtitle": "Transforma transcripciones y PDFs en guiones de enseñanza estructurados y cronometrados usando IA",
+        "input_type_label": "Tipo de Entrada",
+        "input_type_options": ["PDF", "Texto"],
+        "upload_pdf_label": "Subir Transcripción (PDF)",
+        "paste_text_label": "Pegar Texto de Transcripción",
+        "paste_text_placeholder": "Pega tu texto de transcripción aquí...",
+        "guiding_prompt_label": "Instrucciones Guía (Opcional)",
+        "guiding_prompt_placeholder": "Instrucciones adicionales para personalizar el resultado. Ejemplos: 'Usa un tono más informal', 'Enfócate solo en la sección X', 'Genera el contenido en inglés', 'Incluye más ejemplos prácticos de programación', etc.",
+        "guiding_prompt_info": "Las Instrucciones Guía te permiten proporcionar indicaciones específicas para modificar el contenido generado, como el IDIOMA deseado. Puedes usarlas para cambiar el tono, estilo, enfocarte SOLO en secciones específicas del texto, especificar el idioma de salida (ej., 'Generar en inglés/francés/alemán'), o dar cualquier otra instrucción que ayude a personalizar el resultado final.",
+        "duration_label": "Duración Objetivo de la Clase (minutos)",
+        "examples_label": "Incluir Ejemplos Prácticos",
+        "thinking_model_label": "Usar Modelo de Pensamiento Experimental (Solo Gemini)",
+        "submit_button": "Transformar Transcripción",
+        "output_label": "Guión de Enseñanza Generado",
+        "error_no_pdf": "Error: No se ha subido ningún archivo PDF",
+        "error_no_text": "Error: No se ha proporcionado texto",
+        "error_prefix": "Error al procesar la transcripción: ",
+        "language_selector": "Language / Idioma",
+        "show_timestamps": "Mostrar Marcas de Tiempo",
+        "hide_timestamps": "Ocultar Marcas de Tiempo"
+    }
+}
+
+# Language-specific prompt suffixes to append automatically
+LANGUAGE_PROMPTS = {
+    "en": "",  # Default language doesn't need special instructions
+    "es": "Generate the content in Spanish. Genera todo el contenido en español."
+}
+
 class TranscriptTransformerApp:
     def __init__(self):
         self.pdf_processor = PDFProcessor()
         self.text_processor = TextProcessor()
+        self.current_language = "en"  # Default language
+        self.last_generated_content = ""  # Store the last generated content
+        self.content_with_timestamps = ""  # Store content with timestamps
+        self.content_without_timestamps = ""  # Store content without timestamps
 
     def process_transcript(self, 
+                           language: str,
                            input_type: str,
                            file_obj: gr.File = None,
                            raw_text_input: str = "",
@@ -25,6 +87,7 @@ class TranscriptTransformerApp:
         Process uploaded transcript and transform it into a teaching transcript
         
         Args:
+            language: Selected UI language
             input_type: Type of input (PDF or Raw Text)
             file_obj: Uploaded PDF file (if input_type is PDF)
             raw_text_input: Raw text input (if input_type is Raw Text)
@@ -48,70 +111,146 @@ class TranscriptTransformerApp:
             )
             
             # Get text based on input type
-            if input_type == "PDF":
+            if input_type == TRANSLATIONS[language]["input_type_options"][0]:  # PDF
                 if file_obj is None:
-                    return "Error: No PDF file uploaded"
+                    return TRANSLATIONS[language]["error_no_pdf"]
                 raw_text = self.pdf_processor.extract_text(file_obj.name)
             else:  # Raw Text
                 if not raw_text_input.strip():
-                    return "Error: No text provided"
+                    return TRANSLATIONS[language]["error_no_text"]
                 raw_text = raw_text_input
             
+            # Modify initial prompt based on language if no explicit language instruction is given
+            modified_prompt = initial_prompt
+            
+            # Check if user has specified a language in the prompt
+            language_keywords = ["spanish", "español", "english", "inglés", "french", "francés", "german", "alemán"]
+            user_specified_language = any(keyword in initial_prompt.lower() for keyword in language_keywords)
+            
+            # Only append language instruction if user hasn't specified one and we have a non-default language
+            if not user_specified_language and language in LANGUAGE_PROMPTS and LANGUAGE_PROMPTS[language]:
+                if modified_prompt:
+                    modified_prompt += " " + LANGUAGE_PROMPTS[language]
+                else:
+                    modified_prompt = LANGUAGE_PROMPTS[language]
+            
             # Transform to teaching transcript with user guidance
             lecture_transcript = self.transformer.transform_to_lecture(
                 text=raw_text,
                 target_duration=target_duration,
                 include_examples=include_examples,
-                initial_prompt=initial_prompt
+                initial_prompt=modified_prompt
             )
             
+            # Store the generated content
+            self.content_with_timestamps = lecture_transcript
+            
+            # Create a version without timestamps
+            self.content_without_timestamps = self.remove_timestamps(lecture_transcript)
+            
+            # Default: show content with timestamps
+            self.last_generated_content = lecture_transcript
+            
             return lecture_transcript
             
         except Exception as e:
-            return f"Error processing transcript: {str(e)}"
+            return f"{TRANSLATIONS[language]['error_prefix']}{str(e)}"
+    
+    def remove_timestamps(self, text):
+        """Remove all timestamps (e.g., [00:00]) from the text"""
+        # Regex to match the timestamp pattern [MM:SS] or [HH:MM:SS]
+        return re.sub(r'\[\d{1,2}:\d{2}(:\d{2})?\]', '', text)
+    
+    def toggle_timestamps(self, show_timestamps):
+        """Toggle visibility of timestamps in output"""
+        if show_timestamps:
+            return self.content_with_timestamps
+        else:
+            return self.content_without_timestamps
+    
+    def update_ui_language(self, language):
+        """Update UI elements based on selected language"""
+        self.current_language = language
+        
+        translations = TRANSLATIONS[language]
+        
+        return [
+            translations["title"],
+            translations["subtitle"],
+            translations["input_type_label"],
+            gr.update(choices=translations["input_type_options"], value=translations["input_type_options"][0]),
+            translations["upload_pdf_label"],
+            translations["paste_text_label"],
+            translations["paste_text_placeholder"],
+            translations["guiding_prompt_label"],
+            translations["guiding_prompt_placeholder"],
+            translations["guiding_prompt_info"],
+            translations["duration_label"],
+            translations["examples_label"],
+            translations["thinking_model_label"],
+            translations["submit_button"],
+            translations["output_label"]
+        ]
 
     def launch(self):
         """Launch the Gradio interface"""
         # Get the path to the example PDF
         example_pdf = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "sample2.pdf")
         
-        with gr.Blocks(title="AI Script Generator") as interface:
-            gr.Markdown("# AI Script Generator")
-            gr.Markdown("Transform transcripts and PDFs into timed, structured teaching scripts using AI")
+        with gr.Blocks(title=TRANSLATIONS["en"]["title"]) as interface:
+            # Header with title and language selector side by side
+            with gr.Row():
+                with gr.Column(scale=4):
+                    title_md = gr.Markdown("# " + TRANSLATIONS["en"]["title"])
+                with gr.Column(scale=1):
+                    language_selector = gr.Dropdown(
+                        choices=["🇺🇸 English", "🇪🇸 Español"],
+                        value="🇺🇸 English",
+                        label=TRANSLATIONS["en"]["language_selector"],
+                        elem_id="language-selector",
+                        interactive=True
+                    )
             
+            # Subtitle
+            subtitle_md = gr.Markdown(TRANSLATIONS["en"]["subtitle"])
+            
+            # Input type row
             with gr.Row():
                 input_type = gr.Radio(
-                    choices=["PDF", "Raw Text"],
-                    label="Input Type",
-                    value="PDF"
+                    choices=TRANSLATIONS["en"]["input_type_options"],
+                    label=TRANSLATIONS["en"]["input_type_label"],
+                    value=TRANSLATIONS["en"]["input_type_options"][0]
                 )
             
+            # File/text input columns
             with gr.Row():
                 with gr.Column(visible=True) as pdf_column:
                     file_input = gr.File(
-                        label="Upload Transcript (PDF)",
+                        label=TRANSLATIONS["en"]["upload_pdf_label"],
                         file_types=[".pdf"]
                     )
                 
                 with gr.Column(visible=False) as text_column:
                     text_input = gr.Textbox(
-                        label="Paste Transcript Text",
+                        label=TRANSLATIONS["en"]["paste_text_label"],
                         lines=10,
-                        placeholder="Paste your transcript text here..."
+                        placeholder=TRANSLATIONS["en"]["paste_text_placeholder"]
                     )
             
+            # Guiding prompt 
             with gr.Row():
                 initial_prompt = gr.Textbox(
-                    label="Guiding Prompt (Optional)",
+                    label=TRANSLATIONS["en"]["guiding_prompt_label"],
                     lines=3,
                     value="",
-                    placeholder="Additional instructions to customize the output. Examples: 'Use a more informal tone', 'Focus only on section X', 'Generate the content in Spanish', 'Include more practical programming examples', etc.",
-                    info="The Guiding Prompt allows you to provide specific instructions to modify the generated content, like output/desired LANGUAGE. You can use it to change the tone, style, focus ONLY on specific sections of the text, specify the output language (e.g., 'Generate in Spanish/French/German'), or give any other instruction that helps personalize the final result."
+                    placeholder=TRANSLATIONS["en"]["guiding_prompt_placeholder"],
+                    info=TRANSLATIONS["en"]["guiding_prompt_info"]
                 )
             
+            # Settings row
             with gr.Row():
                 target_duration = gr.Number(
-                    label="Target Lecture Duration (minutes)",
+                    label=TRANSLATIONS["en"]["duration_label"],
                     value=30,
                     minimum=2,
                     maximum=60,
@@ -119,40 +258,107 @@ class TranscriptTransformerApp:
                 )
                 
                 include_examples = gr.Checkbox(
-                    label="Include Practical Examples",
+                    label=TRANSLATIONS["en"]["examples_label"],
                     value=True
                 )
                 
                 use_thinking_model = gr.Checkbox(
-                    label="Use Experimental Thinking Model (Gemini Only)",
+                    label=TRANSLATIONS["en"]["thinking_model_label"],
                     value=True
                 )
             
+            # Submit button
             with gr.Row():
-                submit_btn = gr.Button("Transform Transcript")
+                submit_btn = gr.Button(TRANSLATIONS["en"]["submit_button"])
             
+            # Output area
             output = gr.Textbox(
-                label="Generated Teaching Transcript",
+                label=TRANSLATIONS["en"]["output_label"],
                 lines=25
             )
             
+            # Toggle timestamps button and Copy button
+            with gr.Row():
+                timestamps_checkbox = gr.Checkbox(
+                    label=TRANSLATIONS["en"]["show_timestamps"],
+                    value=True,
+                    interactive=True
+                )
+            
+            # Map language dropdown values to language codes
+            lang_map = {
+                "🇺🇸 English": "en",
+                "🇪🇸 Español": "es"
+            }
+            
             # Handle visibility of input columns based on selection
-            def update_input_visibility(choice):
+            def update_input_visibility(language_display, choice):
+                language = lang_map.get(language_display, "en")
+                return [
+                    gr.update(visible=(choice == TRANSLATIONS[language]["input_type_options"][0])),  # pdf_column
+                    gr.update(visible=(choice == TRANSLATIONS[language]["input_type_options"][1]))  # text_column
+                ]
+            
+            # Get language code from display value
+            def get_language_code(language_display):
+                return lang_map.get(language_display, "en")
+            
+            # Update UI elements when language changes
+            def update_ui_with_display(language_display):
+                language = get_language_code(language_display)
+                self.current_language = language
+                
+                translations = TRANSLATIONS[language]
+                
                 return [
-                    gr.update(visible=(choice == "PDF")),  # pdf_column
-                    gr.update(visible=(choice == "Raw Text"))  # text_column
+                    "# " + translations["title"],  # Title with markdown formatting
+                    translations["subtitle"],
+                    translations["input_type_label"],
+                    gr.update(choices=translations["input_type_options"], value=translations["input_type_options"][0], label=translations["input_type_label"]),
+                    gr.update(label=translations["upload_pdf_label"]),
+                    gr.update(label=translations["paste_text_label"], placeholder=translations["paste_text_placeholder"]),
+                    gr.update(label=translations["guiding_prompt_label"], placeholder=translations["guiding_prompt_placeholder"], info=translations["guiding_prompt_info"]),
+                    gr.update(label=translations["duration_label"]),
+                    gr.update(label=translations["examples_label"]),
+                    gr.update(label=translations["thinking_model_label"]),
+                    translations["submit_button"],
+                    gr.update(label=translations["output_label"]),
+                    gr.update(label=translations["show_timestamps"])
                 ]
             
             input_type.change(
-                fn=update_input_visibility,
-                inputs=input_type,
+                fn=lambda lang_display, choice: update_input_visibility(lang_display, choice),
+                inputs=[language_selector, input_type],
                 outputs=[pdf_column, text_column]
             )
             
-            # Set up submission logic
+            # Language change event
+            language_selector.change(
+                fn=update_ui_with_display,
+                inputs=language_selector,
+                outputs=[
+                    title_md, subtitle_md, 
+                    input_type, input_type,
+                    file_input, text_input,
+                    initial_prompt,
+                    target_duration, include_examples, use_thinking_model,
+                    submit_btn, output,
+                    timestamps_checkbox
+                ]
+            )
+            
+            # Toggle timestamps event
+            timestamps_checkbox.change(
+                fn=self.toggle_timestamps,
+                inputs=[timestamps_checkbox],
+                outputs=[output]
+            )
+            
+            # Set up submission logic with language code conversion
             submit_btn.click(
-                fn=self.process_transcript,
+                fn=lambda lang_display, *args: self.process_transcript(get_language_code(lang_display), *args),
                 inputs=[
+                    language_selector,
                     input_type,
                     file_input,
                     text_input,

src/core/transformer.py

@@ -1,7 +1,8 @@
 import os
 import logging
 import json
-from typing import List, Dict, Optional
+import time
+from typing import List, Dict, Optional, Callable, Any
 import openai
 from src.utils.text_processor import TextProcessor
 
@@ -16,7 +17,9 @@ class WordCountError(Exception):
 class TranscriptTransformer:
     """Transforms conversational transcripts into teaching material using LLM"""
     
-    MAX_RETRIES = 3  # Maximum retries for content generation
+    MAX_RETRIES = 3  # Initial retries for content generation
+    EXTENDED_RETRIES = 3  # Additional retries with longer waits
+    EXTENDED_RETRY_DELAYS = [5, 10, 15]  # Wait times in seconds for extended retries
     CHUNK_SIZE = 6000  # Target words per chunk
     LARGE_DEVIATION_THRESHOLD = 0.20  # 20% maximum deviation
     MAX_TOKENS = 64000  # Nuevo límite absoluto basado en 64k tokens de salida
@@ -54,6 +57,49 @@ class TranscriptTransformer:
         # Target word counts
         self.words_per_minute = 130  # Average speaking rate
         
+    def _api_call_with_enhanced_retries(self, call_func: Callable[[], Any]) -> Any:
+        """
+        Wrapper function for API calls with enhanced retry logic
+        
+        Args:
+            call_func: Function that makes the actual API call
+            
+        Returns:
+            The result of the successful API call
+            
+        Raises:
+            Exception: If all retries fail
+        """
+        # Initial retries (already handled by openai client)
+        try:
+            return call_func()
+        except Exception as e:
+            error_str = str(e)
+            
+            # Check if it's a quota error (429)
+            if "429" in error_str or "Too Many Requests" in error_str or "RESOURCE_EXHAUSTED" in error_str:
+                logger.warning(f"Quota error detected: {error_str}")
+                logger.info(f"Starting extended retries with longer waits...")
+                
+                # Extended retries with longer waits
+                for i in range(self.EXTENDED_RETRIES):
+                    wait_time = self.EXTENDED_RETRY_DELAYS[i]
+                    logger.info(f"Extended retry {i+1}/{self.EXTENDED_RETRIES}: Waiting {wait_time} seconds before retry")
+                    time.sleep(wait_time)
+                    
+                    try:
+                        return call_func()
+                    except Exception as retry_error:
+                        # If last retry, re-raise
+                        if i == self.EXTENDED_RETRIES - 1:
+                            logger.error(f"All extended retries failed: {str(retry_error)}")
+                            raise
+                        # Otherwise log and continue to next retry
+                        logger.warning(f"Extended retry {i+1} failed: {str(retry_error)}")
+            else:
+                # Not a quota error, re-raise
+                raise
+        
     def _validate_word_count(self, total_words: int, target_words: int, min_words: int, max_words: int) -> None:
         """Validate word count with flexible thresholds and log warnings/errors"""
         deviation = abs(total_words - target_words) / target_words
@@ -280,7 +326,11 @@ class TranscriptTransformer:
                     }
                 }
 
-            response = self.openai_client.chat.completions.create(**params)
+            # Use the enhanced retry wrapper for API call
+            def api_call():
+                return self.openai_client.chat.completions.create(**params)
+                
+            response = self._api_call_with_enhanced_retries(api_call)
             content = response.choices[0].message.content.strip()
             logger.debug(f"Raw structure response: {content}")
             
@@ -308,86 +358,94 @@ class TranscriptTransformer:
                 
         except Exception as e:
             logger.error(f"Error generating structure: {str(e)}")
+            # Fallback in case of any error
             return self._generate_fallback_structure(text, target_duration)
             
     def _generate_fallback_structure(self, text: str, target_duration: int) -> Dict:
-        """Generate a basic fallback structure when JSON parsing fails"""
+        """Generate a simplified fallback structure in case of parsing failures"""
         logger.info("Generating fallback structure")
         
-        # Generate a simpler structure prompt
-        prompt = f"""
-        Analyze this text and provide:
-        1. A title (one line)
-        2. Three learning objectives (one per line)
-        3. Three main topics (one per line)
-        4. Three key terms (one per line)
-        
-        Text: {text[:1000]}
-        """
+        params = {
+            "model": self.model_name,
+            "messages": [
+                {"role": "system", "content": "You are an expert educator. Output ONLY valid JSON, no other text."},
+                {"role": "user", "content": f"""
+                Create a simplified lecture outline based on this transcript.
+                Format as JSON with: 
+                - title
+                - 3 learning objectives
+                - 2 main topics with title, key concepts, subtopics
+                - 2 practical applications
+                - 3 key terms
+                
+                Target duration: {target_duration} minutes
+                
+                Transcript excerpt:
+                {text[:2000]}
+                """}
+            ],
+            "temperature": 0.5,
+            "max_tokens": 2000
+        }
         
         try:
-            response = self.openai_client.chat.completions.create(
-                model=self.model_name,
-                messages=[
-                    {"role": "system", "content": "You are an expert educator. Provide concise, line-by-line responses."},
-                    {"role": "user", "content": prompt}
-                ],
-                temperature=0.7,
-                max_tokens=1000
-            )
-            
-            lines = response.choices[0].message.content.strip().split('\n')
-            lines = [line.strip() for line in lines if line.strip()]
-            
-            # Extract components from lines
-            title = lines[0] if lines else "Lecture"
-            objectives = [obj for obj in lines[1:4] if obj][:3]
-            topics = [topic for topic in lines[4:7] if topic][:3]
-            terms = [term for term in lines[7:10] if term][:3]
-            
-            # Calculate minutes per topic
-            main_time = int(target_duration * 0.7)  # 70% for main content
-            topic_minutes = main_time // len(topics) if topics else main_time
-            
-            # Create fallback structure
-            return {
-                "title": title,
-                "learning_objectives": objectives,
-                "topics": [
-                    {
-                        "title": topic,
-                        "key_concepts": [topic],  # Use topic as key concept
-                        "subtopics": ["Overview", "Details", "Examples"],
-                        "duration_minutes": topic_minutes,
-                        "objective_links": [1]  # Link to first objective
-                    }
-                    for topic in topics
-                ],
-                "practical_applications": [
-                    "Real-world application example",
-                    "Interactive exercise",
-                    "Case study"
-                ],
-                "key_terms": terms
-            }
+            # Use the enhanced retry wrapper for API call
+            def api_call():
+                return self.openai_client.chat.completions.create(**params)
+                
+            response = self._api_call_with_enhanced_retries(api_call)
+            content = response.choices[0].message.content.strip()
             
+            try:
+                return json.loads(content)
+            except json.JSONDecodeError:
+                # Last resort fallback if everything fails
+                return {
+                    "title": "Lecture on Transcript Topic",
+                    "learning_objectives": ["Understand key concepts", "Apply knowledge", "Evaluate outcomes"],
+                    "topics": [
+                        {
+                            "title": "Main Topic 1",
+                            "key_concepts": ["Concept 1", "Concept 2"],
+                            "subtopics": ["Subtopic 1", "Subtopic 2"],
+                            "duration_minutes": target_duration // 2,
+                            "objective_links": [1, 2]
+                        },
+                        {
+                            "title": "Main Topic 2",
+                            "key_concepts": ["Concept 3", "Concept 4"],
+                            "subtopics": ["Subtopic 3", "Subtopic 4"],
+                            "duration_minutes": target_duration // 2,
+                            "objective_links": [2, 3]
+                        }
+                    ],
+                    "practical_applications": ["Application 1", "Application 2"],
+                    "key_terms": ["Term 1", "Term 2", "Term 3"]
+                }
         except Exception as e:
             logger.error(f"Error generating fallback structure: {str(e)}")
-            # Return minimal valid structure
+            # Hardcoded last resort fallback
             return {
-                "title": "Lecture Overview",
-                "learning_objectives": ["Understand key concepts", "Apply knowledge", "Analyze examples"],
+                "title": "Lecture on Transcript Topic",
+                "learning_objectives": ["Understand key concepts", "Apply knowledge", "Evaluate outcomes"],
                 "topics": [
                     {
-                        "title": "Main Topic",
-                        "key_concepts": ["Core concept"],
-                        "subtopics": ["Overview"],
+                        "title": "Main Topic 1",
+                        "key_concepts": ["Concept 1", "Concept 2"],
+                        "subtopics": ["Subtopic 1", "Subtopic 2"],
                         "duration_minutes": target_duration // 2,
-                        "objective_links": [1]
+                        "objective_links": [1, 2]
+                    },
+                    {
+                        "title": "Main Topic 2",
+                        "key_concepts": ["Concept 3", "Concept 4"],
+                        "subtopics": ["Subtopic 3", "Subtopic 4"],
+                        "duration_minutes": target_duration // 2,
+                        "objective_links": [2, 3]
                     }
                 ],
-                "practical_applications": ["Practical example"],
-                "key_terms": ["Key term"]
+                "practical_applications": ["Application 1", "Application 2"],
+                "key_terms": ["Term 1", "Term 2", "Term 3"]
             }
         
     def _generate_section(self,
@@ -400,24 +458,40 @@ class TranscriptTransformer:
                          is_first: bool = False,
                          is_last: bool = False,
                          initial_prompt: Optional[str] = None) -> str:
-        """Generate content for a specific section with coherence tracking"""
+        """Generate a specific section of the lecture"""
         logger.info(f"Generating {section_type} section (target: {target_words} words)")
         
-        user_instructions = f"\nUser's guiding instructions:\n{initial_prompt}\n" if initial_prompt else ""
+        # Calculate timing markers
+        if section_type == 'introduction':
+            time_marker = '[00:00]'
+        elif section_type == 'summary':
+            duration_mins = sum(topic.get('duration_minutes', 5) for topic in structure_data['topics'])
+            # Asegurar que duration_mins es un entero y nunca menor a 5
+            adjusted_mins = max(5, int(duration_mins - 5))
+            time_marker = f'[{adjusted_mins:02d}:00]'
+        else:
+            # For other sections, use appropriate time markers
+            time_marker = '[XX:XX]'  # Will be replaced within the prompt
+        
+        user_instructions = f"\nAdditional user instructions:\n{initial_prompt}\n" if initial_prompt else ""
         
-        # Base prompt with structure
+        # Base prompt with context-specific formatting
         prompt = f"""
-        You are an expert educator creating a detailed lecture transcript.
+        You are creating a {section_type} section for a {time_marker} teaching lecture on "{structure_data['title']}".
         {user_instructions}
-        Generate the {section_type} section with EXACTLY {target_words} words.
+        Target word count: {target_words} words (very important)
+        
+        Learning objectives:
+        {', '.join(structure_data['learning_objectives'])}
         
-        Lecture Title: {structure_data['title']}
-        Learning Objectives: {', '.join(structure_data['learning_objectives'])}
+        Key terms:
+        {', '.join(structure_data['key_terms'])}
         
-        Current section purpose:
+        Original source:
+        {original_text[:500]}...
         """
         
-        # Add section-specific guidance
+        # Section-specific instructions
         if section_type == 'introduction':
             prompt += """
             - Start with an engaging hook
@@ -427,66 +501,110 @@ class TranscriptTransformer:
             """
         elif section_type == 'main':
             prompt += f"""
-            - Cover these topics: {[t['title'] for t in structure_data['topics']]}
-            - Build progressively on concepts
-            - Include clear transitions
-            - Reference previous concepts
+            Discuss one main topic in depth.
+            
+            Topic: {context['current_topic']['title']}
+            Key concepts: {', '.join(context['current_topic']['key_concepts'])}
+            Subtopics: {', '.join(context['current_topic']['subtopics'])}
+            
+            - Start with appropriate time marker
+            - Explain key concepts clearly
+            - Include real-world examples
+            - Connect to learning objectives
+            - Use appropriate time markers within the section
             """
         elif section_type == 'practical':
-            prompt += """
-            - Apply concepts to real-world scenarios
-            - Connect to previous topics
-            - Include interactive elements
-            - Reinforce key learning points
+            prompt += f"""
+            Create a practical applications section with:
+            
+            - Start with appropriate time marker
+            - 2-3 practical examples or case studies
+            - Clear connections to the main topics
+            - Interactive elements (questions, exercises)
+            
+            Practical applications to cover:
+            {', '.join(structure_data['practical_applications'])}
             """
         elif section_type == 'summary':
             prompt += """
-            - Reinforce key takeaways
-            - Connect back to objectives
-            - Provide next steps
-            - End with a strong conclusion
-            """
+            Create a concise summary:
             
-        # Add context if available
+            - Start with appropriate time marker
+            - Reinforce key learning points
+            - Brief recap of main topics
+            - Call to action or follow-up suggestions
+            """
+        
+        # Context-specific content
         if context:
             prompt += f"""
             
-            Context:
-            - Covered topics: {', '.join(context['covered_topics'])}
-            - Pending topics: {', '.join(context['pending_topics'])}
-            - Key terms used: {', '.join(context['key_terms'])}
-            - Recent narrative: {context['current_narrative']}
-            """
+            Previously covered topics:
+            {', '.join(context['covered_topics'])}
             
-        # Add requirements
-        prompt += f"""
-        
-        Requirements:
-        1. STRICT word count: Generate EXACTLY {target_words} words
-        2. Include practical examples: {include_examples}
-        3. Use clear transitions
-        4. Include engagement points
-        5. Use time markers [MM:SS]
-        6. Reference specific content from transcript
-        7. Maintain narrative flow
-        8. Use key terms consistently
-        """
-        
-        response = self.openai_client.chat.completions.create(
-            model=self.model_name,
-            messages=[
-                {"role": "system", "content": "You are an expert educator creating a coherent lecture transcript."},
-                {"role": "user", "content": prompt}
-            ],
-            temperature=0.7,
-            max_tokens=self._calculate_max_tokens(section_type, target_words)
-        )
-        
-        content = response.choices[0].message.content
-        word_count = self.text_processor.count_words(content)
-        logger.info(f"Section generated: {word_count} words")
+            Pending topics:
+            {', '.join(context['pending_topics'])}
+            
+            Recent narrative context:
+            {context['current_narrative']}
+            """
         
-        return content
+        # First/last section specific instructions
+        if is_first:
+            prompt += """
+            
+            This is the FIRST section of the lecture. Make it engaging and set the tone.
+            """
+        elif is_last:
+            prompt += """
+            
+            This is the FINAL section of the lecture. Ensure proper closure and reinforcement.
+            """
+            
+        # Add section-specific time markers for formatted output
+        if section_type != 'introduction':
+            prompt += """
+            
+            IMPORTANT: Include appropriate time markers [MM:SS] throughout the section.
+            """
+            
+        try:
+            # Prepare API call parameters
+            params = {
+                "model": self.model_name,
+                "messages": [
+                    {"role": "system", "content": "You are an expert educator creating a teaching script."},
+                    {"role": "user", "content": prompt}
+                ],
+                "temperature": 0.7,
+                "max_tokens": self._calculate_max_tokens(section_type, target_words)
+            }
+            
+            # Add thinking config if using experimental model
+            if self.use_thinking_model:
+                params["extra_body"] = {
+                    "thinking_config": {
+                        "include_thoughts": True
+                    }
+                }
+
+            # Use the enhanced retry wrapper for API call
+            def api_call():
+                return self.openai_client.chat.completions.create(**params)
+                
+            response = self._api_call_with_enhanced_retries(api_call)
+            content = response.choices[0].message.content.strip()
+            
+            # Validate output length
+            content_words = self.text_processor.count_words(content)
+            logger.info(f"Section generated: {content_words} words")
+            
+            return content
+            
+        except Exception as e:
+            logger.error(f"Error during content generation: {str(e)}")
+            # Provide a minimal fallback content to avoid complete failure
+            return f"{time_marker} {section_type.capitalize()} (Error during generation)\n\nWe apologize, but there was an error generating this section."
         
     def _calculate_max_tokens(self, section_type: str, target_words: int) -> int:
         """Calculate appropriate max_tokens based on section and model"""
@@ -536,7 +654,7 @@ class TranscriptTransformer:
             topic_target = topic_words[topic['title']]
             
             # Update context for topic
-            context['current_topic'] = topic['title']
+            context['current_topic'] = topic
             if topic['title'] in context['pending_topics']:
                 context['covered_topics'].append(topic['title'])
                 context['pending_topics'].remove(topic['title'])