# Smallest generation
import requests
import time
import matplotlib.pyplot as plt


# API Key
SMALLEST_API = ""


# Define the URL for the Smallest API
url = "https://waves-api.smallest.ai/api/v1/lightning/get_speech"


# Define the payload for the API request
payload = {
   "voice_id": "emily",
   "text": "Hello, my name is Emily. I am a text-to-speech voice.",
   "speed": 1,
   "sample_rate": 24000,
   "add_wav_header": True
}


# Define the headers for the API request
headers = {
   "Authorization": f"Bearer {SMALLEST_API}",
   "Content-Type": "application/json"
}


# Initialize lists to store status codes and latencies
latencies_smallest = []


# Make 10 API requests to measure latency
for i in range(10):
   start_time = time.time()
   response = requests.request("POST", url, json=payload, headers=headers)
   latencies_smallest.append(time.time() - start_time)


# Calculate and print the average latency
average_latency = sum(latencies_smallest) / len(latencies_smallest)
print("Average Latency Smallest.ai: ", average_latency)

from cartesia import Cartesia
import os
CARTESIA_API_KEY = ""
client = Cartesia(api_key=CARTESIA_API_KEY)


latencies_cartesia = []
for i in range(10):
   start_time = time.time()
   data = client.tts.bytes(
       model_id="sonic",
       transcript="Hello, my name is Emily. I am a text-to-speech voice.",
       voice_id="a0e99841-438c-4a64-b679-ae501e7d6091",  # Barbershop Man
       # You can find the supported `output_format`s at https://docs.cartesia.ai/api-reference/tts/bytes
       output_format={
           "container": "raw",
           "encoding": "pcm_f32le",
           "sample_rate": 24000,
       },
   )


   with open("output.wav", "wb") as f:
       f.write(data)


   latencies_cartesia.append(time.time()-start_time)


print("Average Latencies for Cartesia: " , sum(latencies_cartesia)/10)

from cartesia import Cartesia
import os


CARTESIA_API_KEY = ""
client = Cartesia(api_key=CARTESIA_API_KEY)
voice_id = "a0e99841-438c-4a64-b679-ae501e7d6091"
voice = client.voices.get(id=voice_id)
transcript = "Hello, my name is Emily. I am a text-to-speech voice."


# You can check out our models at https://docs.cartesia.ai/getting-started/available-models
model_id = "sonic-english"


# You can find the supported `output_format`s at https://docs.cartesia.ai/reference/api-reference/rest/stream-speech-server-sent-events
output_format = {
   "container": "raw",
   "encoding": "pcm_f32le",
   "sample_rate": 22050,
}

rate = 22050

# Set up the websocket connection
ws = client.tts.websocket()


cartesia_latency_ttfb = []
cartesia_latencies = []


for i in range(10):
    audio_start_time = time.time()
    start_time = time.time()
    stream = None
    # Generate and stream audio using the websocket
    for output in ws.send(
        model_id=model_id,
        transcript=transcript,
        voice_embedding=voice["embedding"],
        stream=True,
        output_format=output_format,
    ):
        buffer = output["audio"]

        if stream == None:
            cartesia_latency_ttfb.append(time.time() - start_time)
            start_time = time.time()
            stream = 1

    cartesia_latencies.append(time.time() - audio_start_time)
  
print("Average time to first byte for Cartesia: " , sum(cartesia_latency_ttfb)/10)
print("Average Latencues for Cartesia: " , sum(cartesia_latencies)/len(cartesia_latencies))

import os
import time
from cartesia import Cartesia
import pandas as pd
import re
import requests


SMALLEST_API = ""
CARTESIA_API_KEY  = ""


client = Cartesia(api_key=CARTESIA_API_KEY)


# Read the Test CSV which has the following structure
#--|---------------------|-|-----------------------|--
#--|        Sentence     |-|      Category         |--
#--|---------------------|-|-----------------------|--
#--|      Sentence text. |-| Category of sentences |--
#--|---------------------|-|-----------------------|--


df = pd.read_csv("tts_test_new.csv")


def generate_audio_cartesia(text, filename, language=True):


   if language:
       data = client.tts.bytes(
           model_id="sonic",
           transcript=text,
           voice_id="faf0731e-dfb9-4cfc-8119-259a79b27e12",  # Apoorva
           # You can find the supported `output_format`s at https://docs.cartesia.ai/api-reference/tts/bytes
           output_format={
               "container": "wav",
               "encoding": "pcm_f32le",
               "sample_rate": 44100,
           },
           language="hi"
       )
   else:
       data = client.tts.bytes(
       model_id="sonic",
       transcript=text,
       voice_id="729651dc-c6c3-4ee5-97fa-350da1f88600", 
       # You can find the supported `output_format`s at https://docs.cartesia.ai/api-reference/tts/bytes
           output_format={
               "container": "wav",
               "encoding": "pcm_f32le",
               "sample_rate": 44100,
           },
       )


   with open(filename, "wb") as f:
       f.write(data)


def generate_audio_smallest(text, filename):
   url = "https://waves-api.smallest.ai/api/v1/lightning/get_speech"
   ## Edit the header - enter Token
   headers = {
       "Authorization": f"Bearer {SMALLEST_API}",
       "Content-Type": "application/json"
   }
   payload = {
       "text": text,
       "voice_id": "arnav",
       "sample_rate": 24000,
       "speed": 1.0,
       "add_wav_header": True
   }
   response = requests.request("POST", url, json=payload, headers=headers)
   if response.status_code == 200:
       with open(filename, 'wb') as wav_file:
           wav_file.write(response.content)
       print(f"Audio file saved as {filename}")
   else:
       print(f"Error Occured with status code {response.text}")


def is_hindi(text):
   return bool(re.search(r'[\u0900-\u097F]', text))


os.makedirs("audio_samples", exist_ok=True)


# Iterate over each sentence in the dataframe and generate audio
for index, row in df.iterrows():
   text = row['sentence']
   category = row['category']




   os.makedirs(f'audio_samples/smallest/{category}', exist_ok=True)
   os.makedirs(f'audio_samples/cartesia/{category}', exist_ok=True)


   smallest_filename = f"audio_samples/smallest/{category}/sentence_{index}.wav"
   cartesia_filename = f"audio_samples/cartesia/{category}/sentence_{index}.wav"


   # generate_audio_smallest(text, smallest_filename)
   generate_audio_cartesia(text, cartesia_filename, language=is_hindi(text))
   generate_audio_smallest(text, smallest_filename)

'''
Installation:


sudo apt install git-lfs


GIT_LFS_SKIP_SMUDGE=1 pip install git+https://github.com/sarulab-speech/UTMOSv2.git


'''


import utmosv2
import os
import csv
import pandas as pd
import pydub
import requests


model = utmosv2.create_model(pretrained=True)


tts_test_df = pd.read_csv('tts_test_new.csv')
categories = tts_test_df['category'].unique()
providers = ["cartesia", 'smallest']


# Evaluate Smallest.ai WAV files
for category in categories:
   for provider in providers:
       os.makedirs('results', exist_ok=True)
       os.makedirs('results/utmos', exist_ok=True)
       print(f'results/utmos/{provider}_{category}.csv')
       print(f"audio_samples/{provider}/{category}")
       if not os.path.exists(f'results/utmos/{provider}_{category}.csv'):
           mos = model.predict(input_dir=f"test_audio/{provider}/{category}")
           with open(f"results/utmos/{provider}_{category}.csv", mode='w', newline='') as file:
               writer = csv.DictWriter(file, fieldnames=['file_path', 'predicted_mos'])
               writer.writeheader()
               writer.writerows(mos)


           print(f"Data has been written to results/utmos/{provider}_{category}.csv")

'''
!pip3 install git+https://github.com/AndreevP/wvmos
'''


from wvmos import get_wvmos
import os
import csv
import pandas as pd
import pydub
import requests
from pathlib import Path
from tqdm import tqdm
import logging
import torch


mos_model = get_wvmos(cuda=True)


tts_test_df = pd.read_csv('tts_test_new.csv')


def evaluate_directory(directory, mos_model, extension):
   """Evaluate all audio files in a directory."""
   results = []
   dir_path = Path(directory)
   audio_files = sorted(dir_path.glob(f"*.{extension}"))


   # For WAV files, calculate directly
   for audio_path in tqdm(audio_files, desc=f"Evaluating {directory}"):
       try:
           score = float(mos_model.calculate_one(str(audio_path)))
           results.append({
               'file': audio_path.name,
               'provider': directory.split('/')[-2],
               'category': directory.split('/')[-1],
               'mos_score': score
           })
       except Exception as e:
           print(f"Error calculating MOS for {audio_path.name}: {str(e)}")
           results.append({
               'file': audio_path.name,
               'provider': directory.split('/')[-2],
               'category': directory.split('/')[-1],
               'mos_score': None
           })


   return results




# Evaluate Smallest.ai WAV files
for category in categories:
   if not os.path.exists(f'results/wvmos/mos_summary_{category}.csv'):
       all_results = []
       if os.path.exists(f'audio_samples/smallest/{category}'):
           results = evaluate_directory(f'audio_samples/smallest/{category}', mos_model, 'wav')
           all_results.extend(results)


       if os.path.exists(f'audio_samples/cartesia/{category}'):
           results = evaluate_directory(f'audio_samples/cartesia/{category}', mos_model, 'wav')
           all_results.extend(results)


       if not all_results:
           print("No audio files found in generated directories!")
       else:
           # Create results DataFrame
           results_df = pd.DataFrame(all_results)


           # Calculate summary statistics
           summary = results_df.groupby('provider')['mos_score'].agg([
               'count', 'mean', 'std', 'min', 'max'
           ]).round(3)


           # Save results
           os.makedirs('results', exist_ok=True)
           os.makedirs('results/wvmos', exist_ok=True)
           results_df.to_csv(f'results/wvmos/detailed_mos_scores_{category}.csv', index=False)
           summary.to_csv(f'results/wvmos/mos_summary_{category}.csv')


           # Print summary
           print("\nMOS Score Summary:")
           print(summary)


           # Print top/bottom samples (only include text if available)
           print("\nTop 1 Best Samples:")
           columns_to_show = ['provider', 'file', 'mos_score']
           if 'text' in results_df.columns:
               columns_to_show.insert(2, 'text')
           print(results_df.nlargest(1, 'mos_score')[columns_to_show])


           print("\nBottom 1 Samples:")
           print(results_df.nsmallest(1, 'mos_score')[columns_to_show])

import pandas as pd
import os


# Function to read UTMOS results
def read_utmos_results(file_path, category):
   df = pd.read_csv(file_path)
   df['provider'] = file_path.split('/')[-1].split('_')[0]
   df['category'] = category
   return df


# Function to read WVMOS results
def read_wvmos_results(file_path, category):
   df = pd.read_csv(file_path)
   df['category'] = category
   return df


# Read UTMOS results
utmos_results = []
for category in categories:
   for provider in providers:
       file_path = f'results/utmos/{provider}_{category}.csv'
       if os.path.exists(file_path):
           utmos_results.append(read_utmos_results(file_path, category))


utmos_df = pd.concat(utmos_results, ignore_index=True)
# Calculate mean MOS scores for UTMOS
utmos_mean_scores = utmos_df.groupby(['provider', 'category'])['predicted_mos'].mean().reset_index()
utmos_mean_scores


# Read WVMOS results
wvmos_results = []
for category in categories:
   file_path = f'results/wvmos/mos_summary_{category}.csv'
   if os.path.exists(file_path):
       wvmos_results.append(read_wvmos_results(file_path, category))


wvmos_df = pd.concat(wvmos_results, ignore_index=True)
wvmos_df
# Merge UTMOS and WVMOS results
comparison_df = pd.merge(utmos_mean_scores, wvmos_df, on=['provider', 'category'], suffixes=('_utmos', '_wvmos'))


# Print the comparison
comparison_df


# Create a CSV with mean MOS for Eleven and Smallest for each category
mean_mos_comparison = comparison_df.pivot(index='category', columns='provider', values='mean')
mean_mos_comparison.columns = providers
mean_mos_comparison.to_csv('mean_mos_comparison.csv')