deprecated copy.py

# import os
# import gradio as gr
# import time
# import math
# import logging
# import matplotlib.pyplot as plt
# import numpy as np
# # from lib.mock_tts import MockTTSModel
# from lib import format_audio_output
# from lib.ui_content import header_html, demo_text_info
# from lib.book_utils import get_available_books, get_book_info, get_chapter_text
# from lib.text_utils import count_tokens
# from tts_model import TTSModel

# # Set HF_HOME for faster restarts with cached models/voices
# os.environ["HF_HOME"] = "/data/.huggingface"

# # Create TTS model instance
# model = TTSModel()

# # Configure logging
# logging.basicConfig(level=logging.DEBUG)
# # Suppress matplotlib debug messages
# logging.getLogger('matplotlib').setLevel(logging.WARNING)
# logger = logging.getLogger(__name__)
# logger.debug("Starting app initialization...")


# model = TTSModel()

# def initialize_model():
#     """Initialize model and get voices"""
#     if model.model is None:
#         if not model.initialize():
#             raise gr.Error("Failed to initialize model")
    
#     voices = model.list_voices()
#     if not voices:
#         raise gr.Error("No voices found. Please check the voices directory.")
        
#     default_voice = 'af_sky' if 'af_sky' in voices else voices[0] if voices else None
    
#     return gr.update(choices=voices, value=default_voice)

# def update_progress(chunk_num, total_chunks, tokens_per_sec, rtf, progress_state, start_time, gpu_timeout, progress):
#     # Calculate time metrics
#     elapsed = time.time() - start_time
#     gpu_time_left = max(0, gpu_timeout - elapsed)
    
#     # Calculate chunk time more accurately
#     prev_total_time = sum(progress_state["chunk_times"]) if progress_state["chunk_times"] else 0
#     chunk_time = elapsed - prev_total_time
    
#     # Validate metrics before adding to state
#     if chunk_time > 0 and tokens_per_sec >= 0:
#         # Update progress state with validated metrics
#         progress_state["progress"] = chunk_num / total_chunks
#         progress_state["total_chunks"] = total_chunks
#         progress_state["gpu_time_left"] = gpu_time_left
#         progress_state["tokens_per_sec"].append(float(tokens_per_sec))
#         progress_state["rtf"].append(float(rtf))
#         progress_state["chunk_times"].append(chunk_time)
    
#     # Only update progress display during processing
#     progress(progress_state["progress"], desc=f"Processing chunk {chunk_num}/{total_chunks} | GPU Time Left: {int(gpu_time_left)}s")

# def generate_speech_from_ui(text, voice_names, speed, gpu_timeout, progress=gr.Progress(track_tqdm=False)):
#     """Handle text-to-speech generation from the Gradio UI"""
#     try:
#         if not text or not voice_names:
#             raise gr.Error("Please enter text and select at least one voice")
            
#         start_time = time.time()
        
#         # Create progress state with explicit type initialization
#         progress_state = {
#             "progress": 0.0,
#             "tokens_per_sec": [],  # Initialize as empty list
#             "rtf": [],  # Initialize as empty list
#             "chunk_times": [],  # Initialize as empty list
#             "gpu_time_left": float(gpu_timeout),  # Ensure float
#             "total_chunks": 0
#         }
        
#         # Handle single or multiple voices
#         if isinstance(voice_names, str):
#             voice_names = [voice_names]
        
#         # Generate speech with progress tracking using combined voice
#         audio_array, duration, metrics = model.generate_speech(
#             text,
#             voice_names,
#             speed,
#             gpu_timeout=gpu_timeout,
#             progress_callback=update_progress,
#             progress_state=progress_state,
#             progress=progress
#         )
    
#         # Format output for Gradio
#         audio_output, duration_text = format_audio_output(audio_array)
        
#         # Create plot and metrics text outside GPU context
#         fig, metrics_text = create_performance_plot(metrics, voice_names)
        
#         return (
#             audio_output,
#             fig,
#             metrics_text
#         )
#     except Exception as e:
#         raise gr.Error(f"Generation failed: {str(e)}")

# def create_performance_plot(metrics, voice_names):
#     """Create performance plot and metrics text from generation metrics"""
#     # Clean and process the data
#     tokens_per_sec = np.array(metrics["tokens_per_sec"])
#     rtf_values = np.array(metrics["rtf"])
    
#     # Calculate statistics using cleaned data
#     median_tps = float(np.median(tokens_per_sec))
#     mean_tps = float(np.mean(tokens_per_sec))
#     std_tps = float(np.std(tokens_per_sec))
    
#     # Set y-axis limits based on data range
#     y_min = max(0, np.min(tokens_per_sec) * 0.9)
#     y_max = np.max(tokens_per_sec) * 1.1
    
#     # Create plot
#     fig, ax = plt.subplots(figsize=(10, 5))
#     fig.patch.set_facecolor('black')
#     ax.set_facecolor('black')
    
#     # Plot data points
#     chunk_nums = list(range(1, len(tokens_per_sec) + 1))
    
#     # Plot data points
#     ax.bar(chunk_nums, tokens_per_sec, color='#ff2a6d', alpha=0.6)
    
#     # Set y-axis limits with padding
#     padding = 0.1 * (y_max - y_min)
#     ax.set_ylim(max(0, y_min - padding), y_max + padding)
    
#     # Add median line
#     ax.axhline(y=median_tps, color='#05d9e8', linestyle='--', 
#               label=f'Median: {median_tps:.1f} tokens/sec')
    
#     # Style improvements
#     ax.set_xlabel('Chunk Number', fontsize=24, labelpad=20, color='white')
#     ax.set_ylabel('Tokens per Second', fontsize=24, labelpad=20, color='white')
#     ax.set_title('Processing Speed by Chunk', fontsize=28, pad=30, color='white')
#     ax.tick_params(axis='both', which='major', labelsize=20, colors='white')
#     ax.spines['bottom'].set_color('white')
#     ax.spines['top'].set_color('white')
#     ax.spines['left'].set_color('white')
#     ax.spines['right'].set_color('white')
#     ax.grid(False)
#     ax.legend(fontsize=20, facecolor='black', edgecolor='#05d9e8', loc='lower left', 
#              labelcolor='white')
    
#     plt.tight_layout()
    
#     # Calculate average RTF from individual chunk RTFs
#     rtf = np.mean(rtf_values)
    
#     # Prepare metrics text
#     metrics_text = (
#         f"Median Speed: {median_tps:.1f} tokens/sec (o200k_base)\n" +
#         f"Real-time Factor: {rtf:.3f}\n" +
#         f"Real Time Speed: {int(1/rtf)}x\n" +
#         f"Processing Time: {int(metrics['total_time'])}s\n" +
#         f"Total Tokens: {metrics['total_tokens']} (o200k_base)\n" +
#         f"Voices: {', '.join(voice_names)}"
#     )
    
#     return fig, metrics_text


# # Create Gradio interface
# with gr.Blocks(title="Kokoro TTS Demo", css="""
#     .equal-height {
#         min-height: 400px;
#         display: flex;
#         flex-direction: column;
#     }
#     .token-label {
#         font-size: 1rem;
#         margin-bottom: 0.3rem;
#         text-align: center;
#         padding: 0.2rem 0;
#     }
#     .token-count {
#         color: #4169e1;
#     }
# """) as demo:
#     gr.HTML(header_html)
    
#     with gr.Row():
#         # Column 1: Text Input and Book Selection
#         with gr.Column(elem_classes="equal-height"):
#             # Book selection
#             books = get_available_books()
#             book_dropdown = gr.Dropdown(
#                 label="Select Book",
#                 choices=[book['label'] for book in books],
#                 value=books[0]['label'] if books else None,
#                 type="value",
#                 allow_custom_value=True
#             )
            
#             # Initialize chapters for first book
#             initial_book = books[0]['value'] if books else None
#             initial_chapters = []
#             if initial_book:
#                 book_path = os.path.join("texts/processed", initial_book)
#                 _, chapters = get_book_info(book_path)
#                 initial_chapters = [ch['title'] for ch in chapters]
            
#             # Chapter selection with initial chapters
#             chapter_dropdown = gr.Dropdown(
#                 label="Select Chapter",
#                 choices=initial_chapters,
#                 value=initial_chapters[0] if initial_chapters else None,
#                 type="value",
#                 allow_custom_value=True
#             )
#             lab_tps = 175
#             lab_rts = 50
#             # Text input area with initial chapter text
#             initial_text = ""
#             if initial_chapters and initial_book:
#                 book_path = os.path.join("texts/processed", initial_book)
#                 _, chapters = get_book_info(book_path)
#                 if chapters:
#                     initial_text = get_chapter_text(book_path, chapters[0]['id'])
#                     tokens = count_tokens(initial_text)
#                     time_estimate = math.ceil(tokens / lab_tps)
#                     output_estimate = (time_estimate * lab_rts)//60
#                     initial_label = f'<div class="token-label"><span class="token-count">Estimated {output_estimate} minutes in ~{time_estimate}s</span></div>'
#                 else:
#                     initial_label = '<div class="token-label"></div>'
#             else:
#                 initial_label = '<div class="token-label"></div>'
            
#             def update_text_label(text):
#                 if not text:
#                     return '<div class="token-label"></div>'
#                 tokens = count_tokens(text)
#                 time_estimate = math.ceil(tokens / lab_tps)
#                 output_estimate = (time_estimate * lab_rts)//60 
#                 return  f'<div class="token-label"><span class="token-count">Estimated {output_estimate} minutes in ~{time_estimate}s</span></div>'

            
#             text_input = gr.TextArea(
#                 label=None,
#                 placeholder="Enter text here, select a chapter, or upload a .txt file",
#                 value=initial_text,
#                 lines=8,
#                 max_lines=14,
#                 show_label=False,
#                 show_copy_button=True  # Add copy button for convenience
#             )
            
#             clear_btn = gr.Button("Clear Text", variant="secondary")
#             label_html = gr.HTML(initial_label)
            
#             def clear_text():
#                 return "", '<div class="token-label"></div>'
            
#             clear_btn.click(
#                 fn=clear_text,
#                 outputs=[text_input, label_html]
#             )
            
#             # Update label whenever text changes
#             text_input.change(
#                 fn=update_text_label,
#                 inputs=[text_input],
#                 outputs=[label_html],
#                 trigger_mode="always_last"
#             )
            
#             def update_chapters(book_name):
#                 if not book_name:
#                     return gr.update(choices=[], value=None), "", '<div class="token-label"></div>'
#                 # Find the corresponding book file
#                 book_file = next((book['value'] for book in books if book['label'] == book_name), None)
#                 if not book_file:
#                     return gr.update(choices=[], value=None), "", '<div class="token-label"></div>'
#                 book_path = os.path.join("texts/processed", book_file)
#                 book_title, chapters = get_book_info(book_path)
#                 # Create simple choices list of chapter titles
#                 chapter_choices = [ch['title'] for ch in chapters]
#                 # Set initial chapter text when book is selected
#                 initial_text = get_chapter_text(book_path, chapters[0]['id']) if chapters else ""
#                 if initial_text:
#                     tokens = count_tokens(initial_text)
#                     time_estimate = math.ceil(tokens / 150 / 10) * 10
#                     label = f'<div class="token-label"><span class="token-count">({tokens} tokens, ~{time_estimate}s generation time)</span></div>'
#                 else:
#                     label = '<div class="token-label"></div>'
#                 return gr.update(choices=chapter_choices, value=chapter_choices[0] if chapter_choices else None), initial_text, label
            
#             def load_chapter_text(book_name, chapter_title):
#                 if not book_name or not chapter_title:
#                     return "", '<div class="token-label"></div>'
#                 # Find the corresponding book file
#                 book_file = next((book['value'] for book in books if book['label'] == book_name), None)
#                 if not book_file:
#                     return "", '<div class="token-label"></div>'
#                 book_path = os.path.join("texts/processed", book_file)
#                 # Get all chapters and find the one matching the title
#                 _, chapters = get_book_info(book_path)
#                 for ch in chapters:
#                     if ch['title'] == chapter_title:
#                         text = get_chapter_text(book_path, ch['id'])
#                         tokens = count_tokens(text)
#                         time_estimate = math.ceil(tokens / 150 / 10) * 10
#                         return text, f'<div class="token-label"> <span class="token-count">({tokens} tokens, ~{time_estimate}s generation time)</span></div>'
#                 return "", '<div class="token-label"></div>'
            
#             # Set up event handlers for book/chapter selection
#             book_dropdown.change(
#                 fn=update_chapters,
#                 inputs=[book_dropdown],
#                 outputs=[chapter_dropdown, text_input, label_html]
#             )
            
#             chapter_dropdown.change(
#                 fn=load_chapter_text,
#                 inputs=[book_dropdown, chapter_dropdown],
#                 outputs=[text_input, label_html]
#             )
        
#         # Column 2: Controls
#         with gr.Column(elem_classes="equal-height"):
#             file_input = gr.File(
#                 label="Upload .txt file",
#                 file_types=[".txt"],
#                 type="binary"
#             )
            
#             def load_text_from_file(file_bytes):
#                 if file_bytes is None:
#                     return None, '<div class="token-label"></div>'
#                 try:
#                     text = file_bytes.decode('utf-8')
#                     tokens = count_tokens(text)
#                     time_estimate = math.ceil(tokens / 150 / 10) * 10  # Round up to nearest 10 seconds
#                     return text, f'<div class="token-label"><span class="token-count">({tokens} tokens, ~{time_estimate}s generation time)</span></div>'
#                 except Exception as e:
#                     raise gr.Error(f"Failed to read file: {str(e)}")

#             file_input.change(
#                 fn=load_text_from_file,
#                 inputs=[file_input],
#                 outputs=[text_input, label_html]
#             )
            
#             with gr.Group():
#                 voice_dropdown = gr.Dropdown(
#                     label="Voice(s)",
#                     choices=[],  # Start empty, will be populated after initialization
#                     value=None,
#                     allow_custom_value=True,
#                     multiselect=True
#                 )
                
#                 # Add refresh button to manually update voice list
#                 refresh_btn = gr.Button("🔄 Refresh Voices", size="sm")
                
#                 speed_slider = gr.Slider(
#                     label="Speed",
#                     minimum=0.5,
#                     maximum=2.0,
#                     value=1.0,
#                     step=0.1
#                 )
#                 gpu_timeout_slider = gr.Slider(
#                     label="GPU Timeout (seconds)",
#                     minimum=15,
#                     maximum=120,
#                     value=90,
#                     step=1,
#                     info="Maximum time allowed for GPU processing"
#                 )
#                 submit_btn = gr.Button("Generate Speech", variant="primary")
        
#         # Column 3: Output
#         with gr.Column(elem_classes="equal-height"):
#             audio_output = gr.Audio(
#                 label="Generated Speech",
#                 type="numpy",
#                 format="wav",
#                 autoplay=False
#             )
#             progress_bar = gr.Progress(track_tqdm=False)
#             metrics_text = gr.Textbox(
#                 label="Performance Summary",
#                 interactive=False,
#                 lines=5
#             )
#             metrics_plot = gr.Plot(
#                 label="Processing Metrics",
#                 show_label=True,
#                 format="png"  # Explicitly set format to PNG which is supported by matplotlib
#             )
    
#     # Set up event handlers
#     refresh_btn.click(
#         fn=initialize_model,
#         outputs=[voice_dropdown]
#     )
    
#     submit_btn.click(
#         fn=generate_speech_from_ui,
#         inputs=[text_input, voice_dropdown, speed_slider, gpu_timeout_slider],
#         outputs=[audio_output, metrics_plot, metrics_text],
#         show_progress=True
#     )
    
#     # Add text analysis info
#     with gr.Row():
#         with gr.Column():
#             gr.Markdown(demo_text_info)
    
#     # Initialize voices on load
#     demo.load(
#         fn=initialize_model,
#         outputs=[voice_dropdown]
#     )

# # Launch the app
# if __name__ == "__main__":
#     demo.launch()