Upload 7 files

README.md

@@ -1,14 +1,56 @@
 ---
-title: PodXplainClone
-emoji: 👀
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.31.0
-app_file: app.py
-pinned: false
 license: mit
-short_description: 'PodXplain '
+title: 🎙️ PodXplain
+sdk: gradio
+emoji: 📚
+colorFrom: red
+colorTo: blue
+pinned: true
+short_description: PodXplain is a Hugging Face-hosted application that converts
 ---
+# 🎙️ PodXplain
+
+**From script to story — voice it like never before.**
+
+PodXplain is a Hugging Face-hosted application that converts long-form text into engaging multi-speaker podcast-style audio. Simply input your script, and get a professional-sounding MP3 podcast with automatic speaker detection and assignment.
+
+## ✨ Features
+
+- **📝 Long-form Support**: Handle up to 50,000 characters of text
+- **🎭 Multi-speaker Audio**: Automatic speaker detection and assignment
+- **🔄 Smart Segmentation**: Intelligent text splitting with progress tracking
+- **🎵 High-quality Output**: MP3 format for optimal file size and compatibility
+- **🚀 Real-time Progress**: Live updates during generation
+- **🎨 Modern UI**: Clean, intuitive Gradio interface
+
+## 🛠️ Tech Stack
+
+- **Frontend**: Gradio for interactive web interface
+- **TTS Engine**: Nari DIA 1.6B for natural voice synthesis (currently mocked)
+- **Audio Processing**: pydub for audio manipulation and MP3 conversion
+- **Hosting**: Hugging Face Spaces with GPU support
+
+## 📋 How to Use
+
+1.  **Input Text**: Paste or type your podcast script (up to 50,000 characters)
+2.  **Choose Mode**: Select speaker detection mode:
+    * **Auto**: Smart detection based on content structure
+    * **Paragraph**: Speaker changes at paragraph breaks
+    * **Dialogue**: Detection based on dialogue markers
+3.  **Generate**: Click "Generate Podcast" and watch the progress
+4.  **Download**: Get your MP3 file and listen to your podcast!
+
+## 🚀 Quick Start
+
+### Local Development
+
+```bash
+# Clone the repository
+git clone [https://github.com/yourusername/podxplain.git](https://github.com/yourusername/podxplain.git) # Replace with your actual repo URL
+cd podxplain
+
+# Install dependencies
+pip install -r requirements.txt
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Run the application
+python app.py

app.py

@@ -0,0 +1,262 @@
+# app.py - Main Gradio application
+import gradio as gr
+import os
+import tempfile
+import shutil
+from pathlib import Path
+import asyncio
+from typing import List, Tuple, Generator
+import logging
+from datetime import datetime
+
+# Import our custom modules
+from segmenter import TextSegmenter
+from tts_engine import NariDIAEngine
+from audio_utils import AudioProcessor
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class PodXplainApp:
+    def __init__(self):
+        self.segmenter = TextSegmenter()
+        self.tts_engine = NariDIAEngine()
+        self.audio_processor = AudioProcessor()
+        self.temp_dir = None
+        
+    def create_temp_directory(self) -> str:
+        """Create a temporary directory for processing."""
+        if self.temp_dir:
+            shutil.rmtree(self.temp_dir, ignore_errors=True)
+        self.temp_dir = tempfile.mkdtemp(prefix="podxplain_")
+        return self.temp_dir
+    
+    def cleanup_temp_directory(self):
+        """Clean up temporary files."""
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir, ignore_errors=True)
+            self.temp_dir = None
+    
+    def generate_podcast(
+        self, 
+        text: str, 
+        speaker_detection_mode: str = "auto",
+        progress=gr.Progress()
+    ) -> Tuple[str, str]:
+        """
+        Main function to convert text to podcast audio.
+        
+        Args:
+            text: Input text (up to 50,000 characters)
+            speaker_detection_mode: How to detect speaker changes
+            progress: Gradio progress tracker
+            
+        Returns:
+            Tuple of (audio_path, status_message)
+        """
+        try:
+            # Validate input
+            if not text or len(text.strip()) == 0:
+                return None, "❌ Please provide some text to convert."
+            
+            if len(text) > 50000:
+                return None, f"❌ Text too long ({len(text)} chars). Maximum is 50,000 characters."
+            
+            # Create temporary directory
+            temp_dir = self.create_temp_directory()
+            progress(0, desc="🚀 Starting podcast generation...")
+            
+            # Step 1: Segment text and assign speakers
+            progress(0.1, desc="📝 Analyzing text and assigning speakers...")
+            segments = self.segmenter.segment_and_assign_speakers(
+                text, mode=speaker_detection_mode
+            )
+            
+            if not segments:
+                return None, "❌ Could not process the text. Please check the input."
+            
+            logger.info(f"Generated {len(segments)} segments")
+            
+            # Step 2: Generate audio for each segment
+            progress(0.2, desc="🎤 Generating audio segments...")
+            audio_files = []
+            
+            for i, (speaker, segment_text) in enumerate(segments):
+                progress(
+                    0.2 + (0.7 * i / len(segments)), 
+                    desc=f"🎵 Processing segment {i+1}/{len(segments)} (Speaker {speaker})"
+                )
+                
+                # Generate audio for this segment
+                audio_path = self.tts_engine.synthesize_segment(
+                    segment_text, 
+                    speaker, 
+                    os.path.join(temp_dir, f"segment_{i:03d}.wav")
+                )
+                
+                if audio_path:
+                    audio_files.append(audio_path)
+                else:
+                    logger.warning(f"Failed to generate audio for segment {i}")
+            
+            if not audio_files:
+                return None, "❌ Failed to generate any audio segments."
+            
+            # Step 3: Merge audio files and convert to MP3
+            progress(0.9, desc="🔧 Merging segments and converting to MP3...")
+            final_audio_path = self.audio_processor.merge_and_convert_to_mp3(
+                audio_files, 
+                os.path.join(temp_dir, "podcast_output.mp3")
+            )
+            
+            if not final_audio_path:
+                return None, "❌ Failed to merge audio segments."
+            
+            progress(1.0, desc="✅ Podcast generated successfully!")
+            
+            # Generate summary
+            total_segments = len(segments)
+            speakers_used = len(set(speaker for speaker, _ in segments))
+            duration_estimate = len(text) / 1000 * 60  # Rough estimate: 1000 chars ≈ 1 minute
+            
+            status_message = f"""
+            ✅ **Podcast Generated Successfully!**
+            
+            📊 **Statistics:**
+            - Total segments: {total_segments}
+            - Speakers used: {speakers_used}
+            - Estimated duration: {duration_estimate:.1f} minutes
+            - Character count: {len(text):,}
+            
+            🎧 **Your podcast is ready for download!**
+            """
+            
+            return final_audio_path, status_message
+            
+        except Exception as e:
+            logger.error(f"Error generating podcast: {str(e)}")
+            return None, f"❌ Error: {str(e)}"
+        
+        finally:
+            # Clean up temporary files (except the final output)
+            # Note: We keep the final MP3 for download
+            pass
+
+def create_gradio_interface():
+    """Create the Gradio interface."""
+    app = PodXplainApp()
+    
+    # Custom CSS for better styling
+    css = """
+    .main-container {
+        max-width: 1200px;
+        margin: 0 auto;
+    }
+    .header {
+        text-align: center;
+        padding: 20px;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border-radius: 10px;
+        margin-bottom: 20px;
+    }
+    .footer {
+        text-align: center;
+        padding: 20px;
+        color: #666;
+        font-size: 0.9em;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="PodXplain - Text to Podcast") as interface:
+        # Header
+        gr.HTML("""
+        <div class="header">
+            <h1>🎙️ PodXplain</h1>
+            <p><em>From script to story — voice it like never before.</em></p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Input section
+                gr.Markdown("## 📝 Input Your Script")
+                
+                text_input = gr.Textbox(
+                    label="Podcast Script",
+                    placeholder="Enter your podcast script here (up to 50,000 characters).\n\nTip: Use paragraph breaks to help with speaker detection.",
+                    lines=15,
+                    max_lines=20,
+                    show_label=True
+                )
+                
+                char_count = gr.HTML("Characters: 0 / 50,000")
+                
+                # Options
+                speaker_mode = gr.Radio(
+                    choices=["auto", "paragraph", "dialogue"],
+                    value="auto",
+                    label="Speaker Detection Mode",
+                    info="How to detect when speakers change"
+                )
+                
+                generate_btn = gr.Button(
+                    "🎤 Generate Podcast", 
+                    variant="primary", 
+                    size="lg"
+                )
+            
+            with gr.Column(scale=1):
+                # Output section
+                gr.Markdown("## 🎧 Your Podcast")
+                
+                status_output = gr.Markdown("Ready to generate your podcast!")
+                
+                audio_output = gr.Audio(
+                    label="Generated Podcast",
+                    show_download_button=True,
+                    interactive=False
+                )
+        
+        # Footer with instructions
+        gr.HTML("""
+        <div class="footer">
+            <h3>📋 How to Use PodXplain</h3>
+            <ol>
+                <li><strong>Write your script:</strong> Enter up to 50,000 characters of text</li>
+                <li><strong>Choose speaker mode:</strong> Auto-detect, paragraph-based, or dialogue-based</li>
+                <li><strong>Generate:</strong> Click the button and wait for processing</li>
+                <li><strong>Listen & Download:</strong> Your MP3 podcast will be ready!</li>
+            </ol>
+            <p><strong>💡 Tips:</strong> Use clear paragraph breaks for better speaker detection. 
+            Write naturally as if speaking to an audience.</p>
+        </div>
+        """)
+        
+        # JavaScript for character counting
+        text_input.change(
+            fn=lambda text: f"Characters: {len(text) if text else 0:,} / 50,000",
+            inputs=[text_input],
+            outputs=[char_count]
+        )
+        
+        # Main generation function
+        generate_btn.click(
+            fn=app.generate_podcast,
+            inputs=[text_input, speaker_mode],
+            outputs=[audio_output, status_output],
+            show_progress=True
+        )
+    
+    return interface
+
+if __name__ == "__main__":
+    # Create and launch the interface
+    interface = create_gradio_interface()
+    interface.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )

audio_utils.py

@@ -0,0 +1,110 @@
+# audio_utils.py - Audio processing utilities
+import logging
+from typing import List, Optional
+import os
+import tempfile
+from pydub import AudioSegment
+from pydub.utils import which
+
+logger = logging.getLogger(__name__)
+
+class AudioProcessor:
+    def __init__(self):
+        self._check_dependencies()
+    
+    def _check_dependencies(self):
+        """Check if required audio processing tools are available."""
+        # Check for ffmpeg
+        if not which("ffmpeg"):
+            logger.warning("ffmpeg not found. Some audio operations may fail.")
+    
+    def merge_and_convert_to_mp3(
+        self, 
+        audio_files: List[str], 
+        output_path: str
+    ) -> Optional[str]:
+        """
+        Merge multiple audio files and convert to MP3.
+        
+        Args:
+            audio_files: List of paths to audio files to merge
+            output_path: Path for the output MP3 file
+            
+        Returns:
+            Path to the merged MP3 file, or None if failed
+        """
+        try:
+            if not audio_files:
+                logger.error("No audio files to merge")
+                return None
+            
+            logger.info(f"Merging {len(audio_files)} audio files...")
+            
+            # Start with empty audio
+            merged_audio = AudioSegment.empty()
+            
+            for i, audio_file in enumerate(audio_files):
+                if not os.path.exists(audio_file):
+                    logger.warning(f"Audio file not found: {audio_file}")
+                    continue
+                
+                try:
+                    # Load audio segment
+                    segment = AudioSegment.from_wav(audio_file)
+                    
+                    # Add a small pause between segments (500ms)
+                    if i > 0:
+                        pause = AudioSegment.silent(duration=500)
+                        merged_audio += pause
+                    
+                    # Add the segment
+                    merged_audio += segment
+                    
+                    logger.info(f"Added segment {i+1}/{len(audio_files)}")
+                    
+                except Exception as e:
+                    logger.error(f"Failed to process audio file {audio_file}: {e}")
+                    continue
+            
+            if len(merged_audio) == 0:
+                logger.error("No audio content to export")
+                return None
+            
+            # Normalize audio levels
+            merged_audio = self._normalize_audio(merged_audio)
+            
+            # Export as MP3
+            logger.info(f"Exporting to MP3: {output_path}")
+            merged_audio.export(
+                output_path, 
+                format="mp3",
+                bitrate="128k",
+                parameters=["-q:a", "2"]  # Good quality
+            )
+            
+            # Verify the file was created
+            if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
+                duration = len(merged_audio) / 1000.0  # Convert to seconds
+                logger.info(f"Successfully created MP3: {duration:.1f} seconds")
+                return output_path
+            else:
+                logger.error("Failed to create MP3 file")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Failed to merge audio files: {e}")
+            return None
+    
+    def _normalize_audio(self, audio: AudioSegment) -> AudioSegment:
+        """Normalize audio levels."""
+        try:
+            # Apply some basic audio processing
+            # Normalize to -6dB to avoid clipping
+            target_dBFS = -6.0
+            change_in_dBFS = target_dBFS - audio.dBFS
+            normalized_audio = audio.apply_gain(change_in_dBFS)
+            
+            return normalized_audio
+        except Exception as e:
+            logger.warning(f"Failed to normalize audio: {e}")
+            return audio

gitattributes (2).txt

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

requirements.txt

@@ -0,0 +1,11 @@
+gradio>=4.0.0
+transformers>=4.30.0
+torch>=2.0.0
+torchaudio>=2.0.0
+numpy>=1.21.0
+soundfile>=0.12.0
+pydub>=0.25.0
+librosa>=0.10.0
+datasets>=2.10.0
+accelerate>=0.20.0
+git+https://github.com/nari-labs/dia.git # Add this line for Nari DIA

segmenter.py

@@ -0,0 +1,139 @@
+# segmenter.py - Text segmentation and speaker assignment
+import re
+from typing import List, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+class TextSegmenter:
+    def __init__(self):
+        # Changed speakers to Nari DIA's expected tags
+        self.speakers = ["S1", "S2"] 
+        self.current_speaker_index = 0
+    
+    def segment_and_assign_speakers(
+        self, 
+        text: str, 
+        mode: str = "auto"
+    ) -> List[Tuple[str, str]]:
+        """
+        Segment text and assign speakers.
+        
+        Args:
+            text: Input text to segment
+            mode: Segmentation mode ("auto", "paragraph", "dialogue")
+            
+        Returns:
+            List of (speaker, text) tuples
+        """
+        if mode == "paragraph":
+            return self._segment_by_paragraphs(text)
+        elif mode == "dialogue":
+            return self._segment_by_dialogue(text)
+        else:  # auto mode
+            return self._segment_auto(text)
+    
+    def _segment_by_paragraphs(self, text: str) -> List[Tuple[str, str]]:
+        """Segment by paragraphs, alternating speakers."""
+        paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
+        segments = []
+        
+        for i, paragraph in enumerate(paragraphs):
+            speaker = self.speakers[i % len(self.speakers)]
+            segments.append((speaker, paragraph))
+        
+        return segments
+    
+    def _segment_by_dialogue(self, text: str) -> List[Tuple[str, str]]:
+        """Segment by detecting dialogue patterns."""
+        lines = text.split('\n')
+        segments = []
+        current_segment = []
+        # Start with the first speaker in the list
+        current_speaker = self.speakers[0] 
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Check for dialogue markers
+            if (line.startswith('"') or line.startswith("'") or 
+                line.startswith('-') or line.startswith('—')):
+                
+                # Save previous segment
+                if current_segment:
+                    segments.append((current_speaker, ' '.join(current_segment)))
+                
+                # Switch speaker and start new segment
+                self.current_speaker_index = (self.current_speaker_index + 1) % len(self.speakers)
+                current_speaker = self.speakers[self.current_speaker_index]
+                current_segment = [line]
+            else:
+                current_segment.append(line)
+        
+        # Add final segment
+        if current_segment:
+            segments.append((current_speaker, ' '.join(current_segment)))
+        
+        return segments
+    
+    def _segment_auto(self, text: str) -> List[Tuple[str, str]]:
+        """Automatic segmentation using multiple heuristics."""
+        segments = []
+        
+        paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
+        
+        if len(paragraphs) > 1:
+            return self._segment_by_paragraphs(text)
+        
+        sentences = self._split_into_sentences(text)
+        if len(sentences) > 10:
+            return self._segment_by_sentence_groups(sentences)
+        
+        return self._segment_simple(text)
+    
+    def _split_into_sentences(self, text: str) -> List[str]:
+        """Split text into sentences."""
+        # Simple sentence splitting
+        # Use a more robust regex to avoid splitting on abbreviations (e.g., "Mr.")
+        # This is a common simple improvement, though full NLP libraries are best for complex cases.
+        sentences = re.split(r'(?<=[.!?])\s+', text) # Split after . ! ? followed by space
+        return [s.strip() for s in sentences if s.strip()]
+    
+    def _segment_by_sentence_groups(self, sentences: List[str]) -> List[Tuple[str, str]]:
+        """Group sentences and assign to different speakers."""
+        segments = []
+        group_size = max(2, len(sentences) // 8) 
+        
+        for i in range(0, len(sentences), group_size):
+            group = sentences[i:i + group_size]
+            speaker = self.speakers[i // group_size % len(self.speakers)]
+            text_segment = ' '.join(group) # No need to add '.' if already present from sentence splitting
+            segments.append((speaker, text_segment))
+        
+        return segments
+    
+    def _segment_simple(self, text: str) -> List[Tuple[str, str]]:
+        """Simple segmentation for short texts."""
+        words = text.split()
+        total_words = len(words)
+        
+        if total_words < 50:
+            return [(self.speakers[0], text)] # Assign to S1
+        
+        num_segments = min(len(self.speakers), max(2, total_words // 100)) # Limit segments by available speakers
+        segment_size = total_words // num_segments
+        
+        segments = []
+        for i in range(num_segments):
+            start_idx = i * segment_size
+            end_idx = (i + 1) * segment_size if i < num_segments - 1 else total_words
+            
+            segment_words = words[start_idx:end_idx]
+            segment_text = ' '.join(segment_words)
+            speaker = self.speakers[i % len(self.speakers)]
+            
+            segments.append((speaker, segment_text))
+        
+        return segments

tts_engine.py

@@ -0,0 +1,110 @@
+# tts_engine.py - TTS engine wrapper for Nari DIA
+import logging
+import os
+from typing import Optional
+import tempfile
+import numpy as np
+import soundfile as sf
+import torch # Import torch for model operations
+
+# Import the actual Nari DIA model
+try:
+    from dia.model import Dia
+except ImportError:
+    logging.error("Nari DIA library not found. Please ensure 'git+https://github.com/nari-labs/dia.git' is in your requirements.txt and installed.")
+    Dia = None # Set to None to prevent further errors
+
+logger = logging.getLogger(__name__)
+
+class NariDIAEngine:
+    def __init__(self):
+        self.model = None
+        # No separate processor object for Dia, it handles internal processing
+        self._initialize_model()
+    
+    def _initialize_model(self):
+        """Initialize the Nari DIA 1.6B model."""
+        if Dia is None:
+            logger.error("Nari DIA library is not available. Cannot initialize model.")
+            return
+
+        try:
+            logger.info("Initializing Nari DIA 1.6B model from nari-labs/Dia-1.6B...")
+            
+            # Load the Nari DIA model
+            # Use compute_dtype="float16" for potentially better performance/memory on GPU
+            # Ensure you have a GPU with ~10GB VRAM for this.
+            self.model = Dia.from_pretrained("nari-labs/Dia-1.6B", compute_dtype="float16")
+            
+            # Move model to GPU if available
+            if torch.cuda.is_available():
+                self.model.to("cuda")
+                logger.info("Nari DIA model moved to GPU (CUDA).")
+            else:
+                logger.warning("CUDA not available. Nari DIA model will run on CPU, which is not officially supported and will be very slow.")
+
+            logger.info("Nari DIA model initialized successfully.")
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize Nari DIA model: {e}", exc_info=True)
+            self.model = None
+    
+    def synthesize_segment(
+        self, 
+        text: str, 
+        speaker: str, # This will be 'S1' or 'S2' from segmenter
+        output_path: str
+    ) -> Optional[str]:
+        """
+        Synthesize speech for a text segment using Nari DIA.
+        
+        Args:
+            text: Text to synthesize
+            speaker: Speaker identifier ('S1' or 'S2' expected from segmenter)
+            output_path: Path to save the audio file
+            
+        Returns:
+            Path to the generated audio file, or None if failed
+        """
+        if not self.model:
+            logger.error("Nari DIA model not initialized. Cannot synthesize speech.")
+            return None
+        
+        try:
+            # Nari DIA expects [S1] or [S2] tags.
+            # The segmenter is directly outputting "S1" or "S2".
+            # We just need to wrap it in brackets.
+            if speaker in ["S1", "S2"]:
+                dia_speaker_tag = f"[{speaker}]"
+            else:
+                # Fallback in case segmenter outputs something unexpected
+                logger.warning(f"Unexpected speaker tag '{speaker}' from segmenter. Defaulting to [S1].")
+                dia_speaker_tag = "[S1]"
+
+            # Nari DIA expects the speaker tag at the beginning of the segment
+            full_text_input = f"{dia_speaker_tag} {text}"
+            
+            # Generate audio using the Nari DIA model
+            logger.info(f"Synthesizing with Nari DIA: {full_text_input[:100]}...") # Log beginning of text
+            
+            # Pass the text directly to the model's generate method
+            # Nari DIA's Dia class handles internal processing/tokenization
+            with torch.no_grad():
+                # The .generate method should return audio waveform as a PyTorch tensor
+                audio_waveform_tensor = self.model.generate(full_text_input)
+                audio_waveform = audio_waveform_tensor.cpu().numpy().squeeze()
+            
+            # Nari DIA's sampling rate is typically 22050 Hz.
+            # If the Dia model object itself exposes a sampling_rate attribute, use it.
+            # Otherwise, default to 22050 as it's common for TTS models.
+            sampling_rate = getattr(self.model, 'sampling_rate', 22050) 
+            
+            # Save as WAV file
+            sf.write(output_path, audio_waveform, sampling_rate)
+            
+            logger.info(f"Generated audio for {speaker} ({dia_speaker_tag}): {len(text)} characters to {output_path}")
+            return output_path
+            
+        except Exception as e:
+            logger.error(f"Failed to synthesize segment with Nari DIA: {e}", exc_info=True) # exc_info to print full traceback
+            return None