add support for cartesia

app.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "3bedf0dc-8d8e-4ede-a9e6-b8f35136aa00",
    "metadata": {},
    "outputs": [],
@@ -10,41 +10,123 @@
     "#|default_exp app"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "c2496690-28b2-4a79-89d5-f971b4d6f3d4",
+   "metadata": {},
+   "source": [
+    "# Initialization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "736caa6e-d79f-46e6-bf42-6594c8b809d4",
+   "metadata": {},
+   "source": [
+    "## Get/Set Environment Variables"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7baadc12-4748-4938-916f-0a256546c181",
+   "metadata": {},
+   "source": [
+    "If you want to run this locally without having to set up the environment variables in your system, you can create a file called `tts_openai_secrets.py` in the root directory with this content:\n",
+    "```python\n",
+    "import os\n",
+    "os.environ['OPENAI_API_KEY'] = 'sk-XXXXXXXXXXXXXXXXXXXXXX'\n",
+    "os.environ['CARTESIA_API_KEY'] = 'XXXXXXXXXXXXXXXXXXXXXX'\n",
+    "os.environ[\"ALLOWED_OAUTH_PROFILE_USERNAMES\"]= '<huggingface-username1>,<huggingface-username2>'\n",
+    "```"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "667802a7-0f36-4136-a381-e66210b20462",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "OPENAI_API_KEY environment variable was not found.\n",
+      "CARTESIA_API_KEY environment variable was not found.\n",
+      "ALLOWED_OAUTH_PROFILE_USERNAMES environment variable was not found.\n",
+      "import tts_openai_secrets succeeded\n"
+     ]
+    }
+   ],
    "source": [
     "#| export\n",
-    "#tts_openai_secrets.py content:\n",
-    "#import os\n",
-    "#os.environ['OPENAI_API_KEY'] = 'sk-XXXXXXXXXXXXXXXXXXXXXX'\n",
+    "\n",
     "import os\n",
     "secret_import_failed = False\n",
     "try:\n",
+    "    # don't need the openai api key in a variable\n",
     "    _ = os.environ['OPENAI_API_KEY']\n",
     "    print('OPENAI_API_KEY environment variable was found.')\n",
     "except:\n",
     "    print('OPENAI_API_KEY environment variable was not found.')\n",
     "    secret_import_failed = True\n",
     "try:\n",
-    "    GRADIO_PASSWORD = os.environ['GRADIO_PASSWORD']\n",
-    "    print('GRADIO_PASSWORD environment variable was found.')\n",
+    "    CARTESIA_API_KEY = os.environ['CARTESIA_API_KEY']\n",
+    "    print('CARTESIA_API_KEY environment variable was found.')\n",
+    "except:\n",
+    "    print('CARTESIA_API_KEY environment variable was not found.')\n",
+    "    secret_import_failed = True\n",
+    "try:\n",
+    "    ALLOWED_OAUTH_PROFILE_USERNAMES = os.environ['ALLOWED_OAUTH_PROFILE_USERNAMES']\n",
+    "    print('ALLOWED_OAUTH_PROFILE_USERNAMES environment variable was found.')\n",
     "except:\n",
-    "    print('GRADIO_PASSWORD environment variable was not found.')\n",
+    "    print('ALLOWED_OAUTH_PROFILE_USERNAMES environment variable was not found.')\n",
     "    secret_import_failed = True\n",
     "\n",
     "if secret_import_failed == True:\n",
     "    import tts_openai_secrets\n",
-    "    GRADIO_PASSWORD = os.environ['GRADIO_PASSWORD']\n",
+    "    _ = os.environ['OPENAI_API_KEY']\n",
+    "    CARTESIA_API_KEY = os.environ['CARTESIA_API_KEY']\n",
+    "    ALLOWED_OAUTH_PROFILE_USERNAMES = os.environ['ALLOWED_OAUTH_PROFILE_USERNAMES']\n",
     "    print('import tts_openai_secrets succeeded')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
+   "id": "7664bc24-e8a7-440d-851d-eb16dc2d69fb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "REQUIRE_AUTH: False\n"
+     ]
+    }
+   ],
+   "source": [
+    "#| export\n",
+    "# If REQUIRE_AUTH environemnt variable is set to 'false' (from secrets) and HF_SPACE != 1 then we\n",
+    "# are running locally and don't require authentication and authorization, otherwise we do.\n",
+    "# We are using paid API's so don't want anybody/everybody to be able to use our paid services.\n",
+    "if os.environ.get(\"REQUIRE_AUTH\",'true') == 'false' and os.environ.get('HF_SPACE',0) != 1:\n",
+    "    REQUIRE_AUTH = False\n",
+    "else:\n",
+    "    REQUIRE_AUTH = True\n",
+    "print('REQUIRE_AUTH:',REQUIRE_AUTH)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c978095-da2a-43f8-9729-3d845e7056f1",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
    "id": "4d9863fc-969e-409b-8e20-b9c3cd2cc3e7",
    "metadata": {},
    "outputs": [],
@@ -58,12 +140,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "4f486d3a",
    "metadata": {},
    "outputs": [],
    "source": [
     "#| export\n",
+    "import os\n",
     "import gradio as gr\n",
     "import openai\n",
     "from pydub import AudioSegment\n",
@@ -78,15 +161,42 @@
     "    retry,\n",
     "    stop_after_attempt,\n",
     "    wait_random_exponential,\n",
-    ")  # for exponential backoff"
+    ")  # for exponential backoff\n",
+    "import traceback\n",
+    "# from cartesia.tts import CartesiaTTS\n",
+    "import cartesia"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6b425ab4-cecd-4760-84fb-b7f2cc44a565",
+   "metadata": {},
+   "source": [
+    "Set the Gradio TEMP directory. This will be used to save audio files that were generated prior to returning them. The reason we are doing this is because if you return a bytesio object to a Gradio audio object it will not contain the file extension and will not be playable in Safari. If you pass the file to the Gradio audio object it will contain the extension. In addition if you pass the filepath instead of bytesio path, when you download the audio it will have the correct file extenion whereas otherwise it will not."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "852a3a1f-462a-41ab-bc94-b5ba12279ae9",
+   "metadata": {},
+   "source": [
+    "## App Settings/Constants"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "ecb7f207-0fc2-4d19-a313-356c05776832",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "TEMP Dir: /tmp\n"
+     ]
+    }
+   ],
    "source": [
     "#| export\n",
     "TEMP = os.environ.get('GRADIO_TEMP_DIR','/tmp/')\n",
@@ -96,33 +206,115 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "0ffd33b4-cb9b-4c01-bff6-4c3102854ab6",
+   "execution_count": 7,
+   "id": "e5d6cac2-0dee-42d8-9b41-184b5be9cc3f",
    "metadata": {},
    "outputs": [],
    "source": [
     "#| export\n",
+    "providers = dict()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b77ad8d6-3289-463c-b213-1c0cc215b141",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Successfully added OpenAI as Provider\n"
+     ]
+    }
+   ],
+   "source": [
+    "#| export\n",
+    "# Add OpenAI as a provider\n",
     "try:\n",
-    "    tts_models = [o.id for o in openai.models.list().data if 'tts' in o.id]\n",
-    "    print('successfully got tts model list:', tts_models)\n",
-    "except:\n",
-    "    tts_models = ['tts-1']"
+    "    providers['openai'] = {\n",
+    "        'name': 'Open AI',\n",
+    "        'models': {o.id: o.id for o in openai.models.list().data if 'tts' in o.id},\n",
+    "        'voices': {o:{'id':o,'name':o.title()} for o in ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer']},\n",
+    "    }\n",
+    "    print('Successfully added OpenAI as Provider')\n",
+    "except Exception as e:\n",
+    "    print(f\"\"\"Error: Failed to add OpenAI as a provider.\\nException: {repr(e)}\\nTRACEBACK:\\n\"\"\",traceback.format_exc())\n",
+    "# providers"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "2ddbca5d-4b04-43ab-afaf-430802980e78",
+   "execution_count": 9,
+   "id": "87fca48b-a16a-4d2b-919c-75e88e4e5eb5",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Successfully added Cartesia AI as Provider\n"
+     ]
+    }
+   ],
    "source": [
     "#| export\n",
-    "tts_voices = ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer']"
+    "# Add Cartesia AI as a provider\n",
+    "try:\n",
+    "    providers['cartesiaai'] = {\n",
+    "        'name': 'Cartesia AI',\n",
+    "        'models': {'upbeat-moon': 'Sonic Turbo English'},\n",
+    "        'voices': {v['id']:v for k,v in cartesia.tts.CartesiaTTS().get_voices().items()},\n",
+    "    }\n",
+    "    print('Successfully added Cartesia AI as Provider')\n",
+    "except Exception as e:\n",
+    "    print(f\"\"\"Error: Failed to add Cartesia AI as a provider.\\nException: {repr(e)}\\nTRACEBACK:\\n\"\"\",traceback.format_exc())\n",
+    "# providers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6bd2e9ed-9dbd-4d5f-a814-2942108b5935",
+   "metadata": {},
+   "source": [
+    "EXAMPLE: providers\n",
+    "```python\n",
+    "{'openai': {'name': 'Open AI',\n",
+    "  'models': {'tts-1-hd-1106': 'tts-1-hd-1106',\n",
+    "   'tts-1-hd': 'tts-1-hd',\n",
+    "   'tts-1': 'tts-1',\n",
+    "   'tts-1-1106': 'tts-1-1106'},\n",
+    "  'voices': {'alloy': {'id': 'alloy', 'name': 'Alloy'},\n",
+    "   'echo': {'id': 'echo', 'name': 'Echo'},\n",
+    "   'fable': {'id': 'fable', 'name': 'Fable'},\n",
+    "   'onyx': {'id': 'onyx', 'name': 'Onyx'},\n",
+    "   'nova': {'id': 'nova', 'name': 'Nova'},\n",
+    "   'shimmer': {'id': 'shimmer', 'name': 'Shimmer'}}},\n",
+    " 'cartesiaai': {'name': 'Cartesia AI',\n",
+    "  'models': {'upbeat-moon': 'Sonic Turbo English'},\n",
+    "  'voices': {'3b554273-4299-48b9-9aaf-eefd438e3941': {'id': '3b554273-4299-48b9-9aaf-eefd438e3941',\n",
+    "    'user_id': None,\n",
+    "    'is_public': True,\n",
+    "    'name': 'Indian Lady',\n",
+    "    'description': 'This voice is young, rich, and curious, perfect for a narrator or fictional character',\n",
+    "    'created_at': '2024-05-04T18:48:17.006441-07:00',\n",
+    "    'embedding': [0.015546328,-0.11384969,0.14146514, ...]},\n",
+    "   '63ff761f-c1e8-414b-b969-d1833d1c870c': {'id': '63ff761f-c1e8-414b-b969-d1833d1c870c',\n",
+    "    'user_id': None,\n",
+    "    'is_public': True,\n",
+    "    'name': 'Confident British Man',\n",
+    "    'description': 'This voice is disciplined with a British accent, perfect for a commanding character or narrator',\n",
+    "    'created_at': '2024-05-04T18:57:31.399193-07:00',\n",
+    "    'embedding': [-0.056990184,-0.06531749,-0.05618861,...]}\n",
+    "            }\n",
+    "}\n",
+    "```"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "8eb7e7d5-7121-4762-b8d1-e5a9539e2b36",
    "metadata": {},
    "outputs": [],
@@ -133,19 +325,52 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "id": "52d373be-3a79-412e-8ca2-92bb443fa52d",
    "metadata": {},
    "outputs": [],
    "source": [
     "#| export\n",
     "#Number of threads created PER USER REQUEST. This throttels the # of API requests PER USER request. This is in ADDITION to the Gradio threads.\n",
-    "OPENAI_CLIENT_TTS_THREADS = 10 "
+    "OPENAI_CLIENT_TTS_THREADS = 10 \n",
+    "CARTESIAAI_CLIENT_TTS_THREADS = 3\n",
+    "\n",
+    "DEFAULT_PROVIDER = 'openai'\n",
+    "DEFAULT_MODEL = 'tts-1'\n",
+    "DEFAULT_VOICE = 'alloy'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e6400d8e-49e8-41b8-ad0e-18bc032682b6",
+   "metadata": {},
+   "source": [
+    "# Main Implementation"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
+   "id": "b5b29507-92bc-453d-bcc5-6402c17e9a0d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def verify_authorization(profile: gr.OAuthProfile=None) -> str:\n",
+    "    print('Profile:', profile)\n",
+    "    if REQUIRE_AUTH == False:\n",
+    "        return 'WARNING_NO_AUTH_REQUIRED_LOCAL'\n",
+    "    elif profile is not None and profile.username in [\"matdmiller\"]:\n",
+    "        return f\"{profile.username}\"\n",
+    "    else:\n",
+    "        # print('Unauthorized',profile)\n",
+    "        raise PermissionError(f'Your huggingface username ({profile}) is not authorized. Must be set in ALLOWED_OAUTH_PROFILE_USERNAMES environment variable.')\n",
+    "        return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
    "id": "24674094-4d47-4e48-b591-55faabcff8df",
    "metadata": {},
    "outputs": [],
@@ -186,16 +411,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "id": "e6224ae5-3792-42b2-8392-3abd42998a50",
    "metadata": {},
    "outputs": [],
    "source": [
     "#| export\n",
-    "def concatenate_mp3(mp3_files):\n",
-    "    # if len(mp3_files) == 1:\n",
-    "    #     return mp3_files[0]\n",
-    "    # else:\n",
+    "def concatenate_mp3(mp3_files:list):\n",
+    "\n",
     "    # Initialize an empty AudioSegment object for concatenation\n",
     "    combined = AudioSegment.empty()\n",
     "    \n",
@@ -231,7 +454,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "id": "4691703d-ed0f-4481-8006-b2906289b780",
    "metadata": {},
    "outputs": [],
@@ -249,31 +472,101 @@
     "    return chunk_idx, response.content"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "6b1a0a8a-0ff6-44fa-b85c-c80c56bd3a24",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "client.generate(\n",
+    "    *,\n",
+    "    transcript: str,\n",
+    "    voice: List[float],\n",
+    "    model_id: str = '',\n",
+    "    duration: int = None,\n",
+    "    chunk_time: float = None,\n",
+    "    stream: bool = False,\n",
+    "    websocket: bool = True,\n",
+    "    output_format: Union[str, cartesia._types.AudioOutputFormat] = 'fp32',\n",
+    "    data_rtype: str = 'bytes',\n",
+    ") -> Union[cartesia._types.AudioOutput, Generator[cartesia._types.AudioOutput, NoneType, NoneType]]\n",
+    "\n",
+    "list(cartesia._types.AudioOutputFormat)\n",
+    "[<AudioOutputFormat.FP32: 'fp32'>,\n",
+    " <AudioOutputFormat.PCM: 'pcm'>,\n",
+    " <AudioOutputFormat.FP32_16000: 'fp32_16000'>,\n",
+    " <AudioOutputFormat.FP32_22050: 'fp32_22050'>,\n",
+    " <AudioOutputFormat.FP32_44100: 'fp32_44100'>,\n",
+    " <AudioOutputFormat.PCM_16000: 'pcm_16000'>,\n",
+    " <AudioOutputFormat.PCM_22050: 'pcm_22050'>,\n",
+    " <AudioOutputFormat.PCM_44100: 'pcm_44100'>,\n",
+    " <AudioOutputFormat.MULAW_8000: 'mulaw_8000'>]\n",
+    "```"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
+   "id": "3420c868-71cb-4ac6-ac65-6f02bfd841d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def create_speech_cartesiaai(chunk_idx, input, model='upbeat-moon', \n",
+    "                             voice='248be419-c632-4f23-adf1-5324ed7dbf1d', #Hannah\n",
+    "                             websocket=False, output_format='pcm_44100', **kwargs):\n",
+    "    client = cartesia.tts.CartesiaTTS()\n",
+    "    \n",
+    "    @retry(wait=wait_random_exponential(min=1, max=180), stop=stop_after_attempt(6))\n",
+    "    def _create_speech_with_backoff(**kwargs):\n",
+    "        return client.generate(**kwargs)\n",
+    "    \n",
+    "    response = _create_speech_with_backoff(transcript=input, model_id=model, voice_id=voice, \n",
+    "                                           websocket=websocket, output_format=output_format, **kwargs)\n",
+    "    client.close()\n",
+    "    return chunk_idx, response[\"audio\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
    "id": "e34bb4aa-698c-4452-8cda-bd02b38f7122",
    "metadata": {},
    "outputs": [],
    "source": [
     "#| export\n",
-    "def create_speech2(input_text, model='tts-1', voice='alloy', profile: gr.OAuthProfile|None=None, progress=gr.Progress(), **kwargs):\n",
-    "    print('cs2-profile:',profile)\n",
-    "    assert authorized(profile) is not None,'Unauthorized M'\n",
+    "def create_speech(input_text, provider, model='tts-1', voice='alloy', profile: gr.OAuthProfile|None=None, progress=gr.Progress(), **kwargs):\n",
+    "\n",
+    "    verify_authorization(profile)\n",
     "    start = datetime.now()\n",
+    "\n",
+    "    \n",
+    "    if provider == 'cartesiaai':\n",
+    "        create_speech_func = create_speech_cartesiaai\n",
+    "        max_chunk_size = 500\n",
+    "        chunk_processing_time = 20\n",
+    "        threads = CARTESIAAI_CLIENT_TTS_THREADS\n",
+    "    elif provider == 'openai':\n",
+    "        create_speech_func = create_speech_openai\n",
+    "        max_chunk_size = 4000\n",
+    "        chunk_processing_time = 60\n",
+    "        threads = OPENAI_CLIENT_TTS_THREADS\n",
+    "    else:\n",
+    "        raise ValueError(f'Invalid argument provider: {provider}')\n",
+    "    \n",
     "    # Split the input text into chunks\n",
-    "    chunks = split_text(input_text)\n",
+    "    chunks = split_text(input_text, max_length=max_chunk_size)\n",
     "\n",
     "    # Initialize the progress bar\n",
-    "    progress(0, desc=f\"Started processing {len(chunks)} text chunks using {OPENAI_CLIENT_TTS_THREADS} threads. ETA is ~{ceil(len(chunks)/OPENAI_CLIENT_TTS_THREADS)} min.\")\n",
+    "    progress(0, desc=f\"Started processing {len(chunks)} text chunks using {threads} threads. ETA is ~{ceil(len(chunks)/threads)*chunk_processing_time/60.} min.\")\n",
     "\n",
     "    # Initialize a list to hold the audio data of each chunk\n",
     "    audio_data = []\n",
     "\n",
     "    # Process each chunk\n",
-    "    with ThreadPool(processes=OPENAI_CLIENT_TTS_THREADS) as pool:\n",
+    "    with ThreadPool(processes=threads) as pool:\n",
     "        results = pool.starmap(\n",
-    "            partial(create_speech_openai, model=model, voice=voice, **kwargs), \n",
+    "            partial(create_speech_func, model=model, voice=voice, **kwargs), \n",
     "            zip(range(len(chunks)),chunks)\n",
     "        )\n",
     "    audio_data = [o[1] for o in sorted(results)]\n",
@@ -294,58 +587,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "5388e860",
+   "execution_count": 18,
+   "id": "ca2c6f8c-62ed-4ac1-9c2f-e3b2bfb47e8d",
    "metadata": {},
    "outputs": [],
    "source": [
-    "#| export\n",
-    "def create_speech(input_text, model='tts-1', voice='alloy', profile: gr.OAuthProfile|None=None, progress=gr.Progress()):\n",
-    "    assert authorized(profile) is not None,'Unauthorized M'\n",
-    "    # Split the input text into chunks\n",
-    "    chunks = split_text(input_text)\n",
-    "\n",
-    "    # Initialize the progress bar\n",
-    "    progress(0, desc=\"Starting TTS processing...\")\n",
-    "\n",
-    "    # Initialize a list to hold the audio data of each chunk\n",
-    "    audio_data = []\n",
-    "\n",
-    "    # Create a client instance for OpenAI\n",
-    "    client = openai.OpenAI()\n",
-    "\n",
-    "    # Calculate the progress increment for each chunk\n",
-    "    progress_increment = 1.0 / len(chunks)\n",
-    "\n",
-    "    # Process each chunk\n",
-    "    for i, chunk in enumerate(chunks):\n",
-    "        response = client.audio.speech.create(\n",
-    "            model=model,\n",
-    "            voice=voice,\n",
-    "            input=chunk,\n",
-    "            speed=1.0\n",
-    "        )\n",
-    "        # Append the audio content of the response to the list\n",
-    "        audio_data.append(response.content)\n",
-    "\n",
-    "        # Update the progress bar\n",
-    "        progress((i + 1) * progress_increment, desc=f\"Processing chunk {i + 1} of {len(chunks)}\")\n",
-    "\n",
-    "    # Close the client connection\n",
-    "    client.close()\n",
-    "\n",
-    "    # Concatenate the audio data from all chunks\n",
-    "    combined_audio = concatenate_mp3(audio_data)\n",
-    "\n",
-    "    # Final update to the progress bar\n",
-    "    progress(1, desc=\"Processing completed\")\n",
-    "\n",
-    "    return combined_audio\n"
+    "# create_speech(\"Hi. What's your name?\", provider='openai', model='tts-1', voice='alloy')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "id": "236dd8d3-4364-4731-af93-7dcdec6f18a1",
    "metadata": {},
    "outputs": [],
@@ -357,75 +609,142 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "id": "0523a158-ee07-48b3-9350-ee39d4deee7f",
    "metadata": {},
    "outputs": [],
    "source": [
     "#| export\n",
-    "def get_generation_cost(input_text, tts_model_dropdown):\n",
+    "def get_generation_cost(input_text, tts_model_dropdown, provider):\n",
     "    text_len = len(input_text)\n",
-    "    if tts_model_dropdown.endswith('-hd'):\n",
-    "        cost = text_len/1000 * 0.03\n",
+    "    if provider == 'openai':\n",
+    "        if tts_model_dropdown.endswith('-hd'):\n",
+    "            cost = text_len/1000 * 0.03\n",
+    "        else:\n",
+    "            cost = text_len/1000 * 0.015\n",
+    "    elif provider == 'cartesiaai':\n",
+    "        cost = text_len/1000 * 0.065\n",
     "    else:\n",
-    "        cost = text_len/1000 * 0.015\n",
+    "        raise ValueError(f'Invalid argument provider: {provider}')\n",
     "    return \"${:,.3f}\".format(cost)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "b5b29507-92bc-453d-bcc5-6402c17e9a0d",
+   "execution_count": 21,
+   "id": "f4d1ba0b-6960-4e22-8dba-7de70370753a",
    "metadata": {},
    "outputs": [],
    "source": [
     "#| export\n",
-    "def authorized(profile: gr.OAuthProfile=None) -> str:\n",
-    "    print('Profile:', profile)\n",
-    "    if profile is not None and profile.username in [\"matdmiller\"]:\n",
-    "        return f\"{profile.username}\"\n",
-    "    else:\n",
-    "        print('Unauthorized',profile)\n",
-    "    return None"
+    "def get_model_choices(provider):\n",
+    "    return sorted([(v,k) for k,v in providers[provider]['models'].items()])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "e4fb3159-579b-4271-bc96-4cd1e2816eca",
+   "execution_count": 22,
+   "id": "efa28cf2-548d-439f-bf2a-21a5edbf9eba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def update_model_choices(provider):\n",
+    "    choices = get_model_choices(provider)\n",
+    "    return gr.update(choices=choices,value=choices[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "cdc1dde5-5edd-4dbf-bd11-30eb418c571d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def get_voice_choices(provider, model):\n",
+    "    return sorted([(v['name'],v['id']) for v in providers[provider]['voices'].values()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "035c33dd-c8e6-42b4-91d4-6bc5f1b36df3",
    "metadata": {},
    "outputs": [],
    "source": [
     "#| export\n",
-    "with gr.Blocks(title='OpenAI TTS', head='OpenAI TTS', delete_cache=(3600,3600)) as app:\n",
-    "    gr.Markdown(\"# OpenAI TTS\")\n",
-    "    gr.Markdown(\"\"\"Start typing below and then click **Go** to create the speech from your text. The current limit is 4,000 characters. \n",
-    "For requests longer than 4,000 chars they will be broken into chunks of 4,000 or less chars automatically. [Spaces Link](https://matdmiller-tts-openai.hf.space/)\"\"\")\n",
+    "def update_voice_choices(provider, model):\n",
+    "    choices = get_voice_choices(provider, model)\n",
+    "    return gr.update(choices=choices,value=choices[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "e4fb3159-579b-4271-bc96-4cd1e2816eca",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/mathewmiller/anaconda3/envs/gradio1/lib/python3.11/site-packages/gradio/utils.py:1000: UserWarning: Expected 3 arguments for function <function get_generation_cost at 0x1174f2e80>, received 4.\n",
+      "  warnings.warn(\n",
+      "/Users/mathewmiller/anaconda3/envs/gradio1/lib/python3.11/site-packages/gradio/utils.py:1008: UserWarning: Expected maximum 3 arguments for function <function get_generation_cost at 0x1174f2e80>, received 4.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "#| export\n",
+    "with gr.Blocks(title='TTS', head='TTS', delete_cache=(3600,3600)) as app:\n",
+    "    gr.Markdown(\"# TTS\")\n",
+    "    gr.Markdown(\"\"\"Start typing below and then click **Go** to create the speech from your text.\n",
+    "For requests longer than allowed by the API they will be broken into chunks automatically. [Spaces Link](https://matdmiller-tts-openai.hf.space/) | <a href=\"https://matdmiller-tts-openai.hf.space/\" target=\"_blank\">Spaces Link HTML</a>\"\"\")\n",
     "    with gr.Row():\n",
     "        input_text = gr.Textbox(max_lines=100, label=\"Enter text here\")\n",
     "    with gr.Row():\n",
-    "        tts_model_dropdown = gr.Dropdown(value='tts-1',choices=tts_models, label='Model')\n",
-    "        tts_voice_dropdown = gr.Dropdown(value='alloy',choices=tts_voices,label='Voice')\n",
+    "        tts_provider_dropdown = gr.Dropdown(value=DEFAULT_PROVIDER,choices=[(v,k) for k,v in providers.items()], label='Provider')\n",
+    "        tts_model_dropdown = gr.Dropdown(value=DEFAULT_MODEL,choices=get_model_choices(DEFAULT_PROVIDER), label='Model')\n",
+    "        tts_voice_dropdown = gr.Dropdown(value=DEFAULT_VOICE,choices=get_voice_choices(DEFAULT_PROVIDER, DEFAULT_MODEL),label='Voice')\n",
     "        input_text_length = gr.Label(label=\"Number of characters\")\n",
     "        generation_cost = gr.Label(label=\"Generation cost\")\n",
+    "    with gr.Row():\n",
     "        output_audio = gr.Audio()\n",
+    "\n",
+    "    #input_text \n",
     "    input_text.input(fn=get_input_text_len, inputs=input_text, outputs=input_text_length)\n",
-    "    input_text.input(fn=get_generation_cost, inputs=[input_text,tts_model_dropdown], outputs=generation_cost)\n",
-    "    tts_model_dropdown.input(fn=get_generation_cost, inputs=[input_text,tts_model_dropdown], outputs=generation_cost)\n",
+    "    input_text.input(fn=get_generation_cost, \n",
+    "                     inputs=[input_text,tts_model_dropdown,tts_provider_dropdown, tts_provider_dropdown], \n",
+    "                     outputs=tts_voice_dropdown)\n",
+    "\n",
+    "    tts_provider_dropdown.change(fn=update_model_choices, inputs=[tts_provider_dropdown], \n",
+    "                                 outputs=tts_model_dropdown)\n",
+    "    tts_provider_dropdown.change(fn=update_voice_choices, inputs=[tts_provider_dropdown, tts_model_dropdown], \n",
+    "                                 outputs=tts_voice_dropdown)\n",
+    "    \n",
+    "    tts_model_dropdown.change(fn=get_generation_cost, \n",
+    "                              inputs=[input_text,tts_model_dropdown,tts_provider_dropdown], outputs=generation_cost)\n",
+    "    \n",
     "    go_btn = gr.Button(\"Go\")\n",
-    "    go_btn.click(fn=create_speech2, inputs=[input_text, tts_model_dropdown, tts_voice_dropdown], outputs=[output_audio])\n",
+    "    go_btn.click(fn=create_speech, \n",
+    "                 inputs=[input_text, tts_provider_dropdown, tts_model_dropdown, tts_voice_dropdown], \n",
+    "                 outputs=[output_audio])\n",
+    "    \n",
     "    clear_btn = gr.Button('Clear')\n",
     "    clear_btn.click(fn=lambda: '', outputs=input_text)\n",
     "\n",
-    "    gr.LoginButton()\n",
-    "    m = gr.Markdown('')\n",
-    "    app.load(authorized, None, m)\n",
+    "    if REQUIRE_AUTH:\n",
+    "        gr.LoginButton()\n",
+    "        m = gr.Markdown('')\n",
+    "        app.load(verify_authorization, None, m)\n",
     "    "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "id": "a00648a1-891b-470b-9959-f5d502055713",
    "metadata": {},
    "outputs": [],
@@ -439,10 +758,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "id": "4b534fe7-4337-423e-846a-1bdb7cccc4ea",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7860\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "#| hide\n",
     "#Notebook launch\n",
@@ -466,10 +815,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 28,
    "id": "28e8d888-e790-46fa-bbac-4511b9ab796c",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Closing server running on port: 7860\n"
+     ]
+    }
+   ],
    "source": [
     "#| hide\n",
     "app.close()"
@@ -477,10 +834,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "afbc9699-4d16-4060-88f4-cd1251754cbd",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'gr' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[2], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m#| hide\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mgr\u001b[49m\u001b[38;5;241m.\u001b[39mclose_all()\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'gr' is not defined"
+     ]
+    }
+   ],
    "source": [
     "#| hide\n",
     "gr.close_all()"
@@ -488,7 +857,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": 30,
    "id": "0420310d-930b-4904-8bd4-3458ad8bdbd3",
    "metadata": {},
    "outputs": [],

app.py

@@ -1,35 +1,54 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: app.ipynb.
 
 # %% auto 0
-__all__ = ['secret_import_failed', 'TEMP', 'TEMP_DIR', 'tts_voices', 'clean_text_prompt', 'OPENAI_CLIENT_TTS_THREADS',
-           'launch_kwargs', 'queue_kwargs', 'split_text', 'concatenate_mp3', 'create_speech_openai', 'create_speech2',
-           'create_speech', 'get_input_text_len', 'get_generation_cost', 'authorized']
-
-# %% app.ipynb 1
-#tts_openai_secrets.py content:
-#import os
-#os.environ['OPENAI_API_KEY'] = 'sk-XXXXXXXXXXXXXXXXXXXXXX'
+__all__ = ['secret_import_failed', 'TEMP', 'TEMP_DIR', 'providers', 'clean_text_prompt', 'OPENAI_CLIENT_TTS_THREADS',
+           'CARTESIAAI_CLIENT_TTS_THREADS', 'DEFAULT_PROVIDER', 'DEFAULT_MODEL', 'DEFAULT_VOICE', 'launch_kwargs',
+           'queue_kwargs', 'verify_authorization', 'split_text', 'concatenate_mp3', 'create_speech_openai',
+           'create_speech_cartesiaai', 'create_speech', 'get_input_text_len', 'get_generation_cost',
+           'get_model_choices', 'update_model_choices', 'get_voice_choices', 'update_voice_choices']
+
+# %% app.ipynb 4
 import os
 secret_import_failed = False
 try:
+    # don't need the openai api key in a variable
     _ = os.environ['OPENAI_API_KEY']
     print('OPENAI_API_KEY environment variable was found.')
 except:
     print('OPENAI_API_KEY environment variable was not found.')
     secret_import_failed = True
 try:
-    GRADIO_PASSWORD = os.environ['GRADIO_PASSWORD']
-    print('GRADIO_PASSWORD environment variable was found.')
+    CARTESIA_API_KEY = os.environ['CARTESIA_API_KEY']
+    print('CARTESIA_API_KEY environment variable was found.')
+except:
+    print('CARTESIA_API_KEY environment variable was not found.')
+    secret_import_failed = True
+try:
+    ALLOWED_OAUTH_PROFILE_USERNAMES = os.environ['ALLOWED_OAUTH_PROFILE_USERNAMES']
+    print('ALLOWED_OAUTH_PROFILE_USERNAMES environment variable was found.')
 except:
-    print('GRADIO_PASSWORD environment variable was not found.')
+    print('ALLOWED_OAUTH_PROFILE_USERNAMES environment variable was not found.')
     secret_import_failed = True
 
 if secret_import_failed == True:
     import tts_openai_secrets
-    GRADIO_PASSWORD = os.environ['GRADIO_PASSWORD']
+    _ = os.environ['OPENAI_API_KEY']
+    CARTESIA_API_KEY = os.environ['CARTESIA_API_KEY']
+    ALLOWED_OAUTH_PROFILE_USERNAMES = os.environ['ALLOWED_OAUTH_PROFILE_USERNAMES']
     print('import tts_openai_secrets succeeded')
 
-# %% app.ipynb 3
+# %% app.ipynb 5
+# If REQUIRE_AUTH environemnt variable is set to 'false' (from secrets) and HF_SPACE != 1 then we
+# are running locally and don't require authentication and authorization, otherwise we do.
+# We are using paid API's so don't want anybody/everybody to be able to use our paid services.
+if os.environ.get("REQUIRE_AUTH",'true') == 'false' and os.environ.get('HF_SPACE',0) != 1:
+    REQUIRE_AUTH = False
+else:
+    REQUIRE_AUTH = True
+print('REQUIRE_AUTH:',REQUIRE_AUTH)
+
+# %% app.ipynb 8
+import os
 import gradio as gr
 import openai
 from pydub import AudioSegment
@@ -45,31 +64,70 @@ from tenacity import (
     stop_after_attempt,
     wait_random_exponential,
 )  # for exponential backoff
+import traceback
+# from cartesia.tts import CartesiaTTS
+import cartesia
 
-# %% app.ipynb 4
+# %% app.ipynb 11
 TEMP = os.environ.get('GRADIO_TEMP_DIR','/tmp/')
 TEMP_DIR = Path(TEMP)
 print('TEMP Dir:', TEMP_DIR)
 
-# %% app.ipynb 5
+# %% app.ipynb 12
+providers = dict()
+
+# %% app.ipynb 13
+# Add OpenAI as a provider
 try:
-    tts_models = [o.id for o in openai.models.list().data if 'tts' in o.id]
-    print('successfully got tts model list:', tts_models)
-except:
-    tts_models = ['tts-1']
+    providers['openai'] = {
+        'name': 'Open AI',
+        'models': {o.id: o.id for o in openai.models.list().data if 'tts' in o.id},
+        'voices': {o:{'id':o,'name':o.title()} for o in ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer']},
+    }
+    print('Successfully added OpenAI as Provider')
+except Exception as e:
+    print(f"""Error: Failed to add OpenAI as a provider.\nException: {repr(e)}\nTRACEBACK:\n""",traceback.format_exc())
+# providers
 
-# %% app.ipynb 6
-tts_voices = ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer']
+# %% app.ipynb 14
+# Add Cartesia AI as a provider
+try:
+    providers['cartesiaai'] = {
+        'name': 'Cartesia AI',
+        'models': {'upbeat-moon': 'Sonic Turbo English'},
+        'voices': {v['id']:v for k,v in cartesia.tts.CartesiaTTS().get_voices().items()},
+    }
+    print('Successfully added Cartesia AI as Provider')
+except Exception as e:
+    print(f"""Error: Failed to add Cartesia AI as a provider.\nException: {repr(e)}\nTRACEBACK:\n""",traceback.format_exc())
+# providers
 
-# %% app.ipynb 7
+# %% app.ipynb 16
 clean_text_prompt = """Your job is to clean up text that is going to be fed into a text to speech (TTS) model. You must remove parts of the text that would not normally be spoken such as reference marks `[1]`, spurious citations such as `(Reddy et al., 2021; Wu et al., 2022; Chang et al., 2022; Kondratyuk et al., 2023)` and any other part of the text that is not normally spoken. Please also clean up sections and headers so they are on new lines with proper numbering. You must also clean up any math formulas that are salvageable from being copied from a scientific paper. If they are garbled and do not make sense then remove them. You must carefully perform the text cleanup so it is translated into speech that is easy to listen to however you must not modify the text otherwise. It is critical that you repeat all of the text without modifications except for the cleanup activities you've been instructed to do. Also you must clean all of the text you are given, you may not omit any of it or stop the cleanup task early."""
 
 
-# %% app.ipynb 8
+# %% app.ipynb 17
 #Number of threads created PER USER REQUEST. This throttels the # of API requests PER USER request. This is in ADDITION to the Gradio threads.
 OPENAI_CLIENT_TTS_THREADS = 10 
+CARTESIAAI_CLIENT_TTS_THREADS = 3
+
+DEFAULT_PROVIDER = 'openai'
+DEFAULT_MODEL = 'tts-1'
+DEFAULT_VOICE = 'alloy'
+
+# %% app.ipynb 19
+def verify_authorization(profile: gr.OAuthProfile=None) -> str:
+    print('Profile:', profile)
+    if REQUIRE_AUTH == False:
+        return 'WARNING_NO_AUTH_REQUIRED_LOCAL'
+    elif profile is not None and profile.username in ["matdmiller"]:
+        return f"{profile.username}"
+    else:
+        # print('Unauthorized',profile)
+        raise PermissionError(f'Your huggingface username ({profile}) is not authorized. Must be set in ALLOWED_OAUTH_PROFILE_USERNAMES environment variable.')
+        return None
 
-# %% app.ipynb 9
+# %% app.ipynb 20
 def split_text(input_text, max_length=4000, lookback=1000):
     # If the text is shorter than the max_length, return it as is
     if len(input_text) <= max_length:
@@ -102,11 +160,9 @@ def split_text(input_text, max_length=4000, lookback=1000):
 
     return chunks
 
-# %% app.ipynb 10
-def concatenate_mp3(mp3_files):
-    # if len(mp3_files) == 1:
-    #     return mp3_files[0]
-    # else:
+# %% app.ipynb 21
+def concatenate_mp3(mp3_files:list):
+
     # Initialize an empty AudioSegment object for concatenation
     combined = AudioSegment.empty()
     
@@ -139,7 +195,7 @@ def concatenate_mp3(mp3_files):
     print('Saving mp3 file to temp directory: ', filepath)
     return str(filepath)
 
-# %% app.ipynb 11
+# %% app.ipynb 22
 def create_speech_openai(chunk_idx, input, model='tts-1', voice='alloy', speed=1.0, **kwargs):
     client = openai.OpenAI()
     
@@ -151,24 +207,54 @@ def create_speech_openai(chunk_idx, input, model='tts-1', voice='alloy', speed=1
     client.close()
     return chunk_idx, response.content
 
-# %% app.ipynb 12
-def create_speech2(input_text, model='tts-1', voice='alloy', profile: gr.OAuthProfile|None=None, progress=gr.Progress(), **kwargs):
-    print('cs2-profile:',profile)
-    assert authorized(profile) is not None,'Unauthorized M'
+# %% app.ipynb 24
+def create_speech_cartesiaai(chunk_idx, input, model='upbeat-moon', 
+                             voice='248be419-c632-4f23-adf1-5324ed7dbf1d', #Hannah
+                             websocket=False, output_format='pcm_44100', **kwargs):
+    client = cartesia.tts.CartesiaTTS()
+    
+    @retry(wait=wait_random_exponential(min=1, max=180), stop=stop_after_attempt(6))
+    def _create_speech_with_backoff(**kwargs):
+        return client.generate(**kwargs)
+    
+    response = _create_speech_with_backoff(transcript=input, model_id=model, voice_id=voice, 
+                                           websocket=websocket, output_format=output_format, **kwargs)
+    client.close()
+    return chunk_idx, response["audio"]
+
+# %% app.ipynb 25
+def create_speech(input_text, provider, model='tts-1', voice='alloy', profile: gr.OAuthProfile|None=None, progress=gr.Progress(), **kwargs):
+
+    verify_authorization(profile)
     start = datetime.now()
+
+    
+    if provider == 'cartesiaai':
+        create_speech_func = create_speech_cartesiaai
+        max_chunk_size = 500
+        chunk_processing_time = 20
+        threads = CARTESIAAI_CLIENT_TTS_THREADS
+    elif provider == 'openai':
+        create_speech_func = create_speech_openai
+        max_chunk_size = 4000
+        chunk_processing_time = 60
+        threads = OPENAI_CLIENT_TTS_THREADS
+    else:
+        raise ValueError(f'Invalid argument provider: {provider}')
+    
     # Split the input text into chunks
-    chunks = split_text(input_text)
+    chunks = split_text(input_text, max_length=max_chunk_size)
 
     # Initialize the progress bar
-    progress(0, desc=f"Started processing {len(chunks)} text chunks using {OPENAI_CLIENT_TTS_THREADS} threads. ETA is ~{ceil(len(chunks)/OPENAI_CLIENT_TTS_THREADS)} min.")
+    progress(0, desc=f"Started processing {len(chunks)} text chunks using {threads} threads. ETA is ~{ceil(len(chunks)/threads)*chunk_processing_time/60.} min.")
 
     # Initialize a list to hold the audio data of each chunk
     audio_data = []
 
     # Process each chunk
-    with ThreadPool(processes=OPENAI_CLIENT_TTS_THREADS) as pool:
+    with ThreadPool(processes=threads) as pool:
         results = pool.starmap(
-            partial(create_speech_openai, model=model, voice=voice, **kwargs), 
+            partial(create_speech_func, model=model, voice=voice, **kwargs), 
             zip(range(len(chunks)),chunks)
         )
     audio_data = [o[1] for o in sorted(results)]
@@ -187,105 +273,93 @@ def create_speech2(input_text, model='tts-1', voice='alloy', profile: gr.OAuthPr
     return combined_audio
 
 
-# %% app.ipynb 13
-def create_speech(input_text, model='tts-1', voice='alloy', profile: gr.OAuthProfile|None=None, progress=gr.Progress()):
-    assert authorized(profile) is not None,'Unauthorized M'
-    # Split the input text into chunks
-    chunks = split_text(input_text)
-
-    # Initialize the progress bar
-    progress(0, desc="Starting TTS processing...")
-
-    # Initialize a list to hold the audio data of each chunk
-    audio_data = []
-
-    # Create a client instance for OpenAI
-    client = openai.OpenAI()
-
-    # Calculate the progress increment for each chunk
-    progress_increment = 1.0 / len(chunks)
-
-    # Process each chunk
-    for i, chunk in enumerate(chunks):
-        response = client.audio.speech.create(
-            model=model,
-            voice=voice,
-            input=chunk,
-            speed=1.0
-        )
-        # Append the audio content of the response to the list
-        audio_data.append(response.content)
-
-        # Update the progress bar
-        progress((i + 1) * progress_increment, desc=f"Processing chunk {i + 1} of {len(chunks)}")
-
-    # Close the client connection
-    client.close()
-
-    # Concatenate the audio data from all chunks
-    combined_audio = concatenate_mp3(audio_data)
-
-    # Final update to the progress bar
-    progress(1, desc="Processing completed")
-
-    return combined_audio
-
-
-# %% app.ipynb 14
+# %% app.ipynb 27
 def get_input_text_len(input_text):
     return len(input_text)
 
-# %% app.ipynb 15
-def get_generation_cost(input_text, tts_model_dropdown):
+# %% app.ipynb 28
+def get_generation_cost(input_text, tts_model_dropdown, provider):
     text_len = len(input_text)
-    if tts_model_dropdown.endswith('-hd'):
-        cost = text_len/1000 * 0.03
+    if provider == 'openai':
+        if tts_model_dropdown.endswith('-hd'):
+            cost = text_len/1000 * 0.03
+        else:
+            cost = text_len/1000 * 0.015
+    elif provider == 'cartesiaai':
+        cost = text_len/1000 * 0.065
     else:
-        cost = text_len/1000 * 0.015
+        raise ValueError(f'Invalid argument provider: {provider}')
     return "${:,.3f}".format(cost)
 
-# %% app.ipynb 16
-def authorized(profile: gr.OAuthProfile=None) -> str:
-    print('Profile:', profile)
-    if profile is not None and profile.username in ["matdmiller"]:
-        return f"{profile.username}"
-    else:
-        print('Unauthorized',profile)
-    return None
-
-# %% app.ipynb 17
-with gr.Blocks(title='OpenAI TTS', head='OpenAI TTS', delete_cache=(3600,3600)) as app:
-    gr.Markdown("# OpenAI TTS")
-    gr.Markdown("""Start typing below and then click **Go** to create the speech from your text. The current limit is 4,000 characters. 
-For requests longer than 4,000 chars they will be broken into chunks of 4,000 or less chars automatically. [Spaces Link](https://matdmiller-tts-openai.hf.space/)""")
+# %% app.ipynb 29
+def get_model_choices(provider):
+    return sorted([(v,k) for k,v in providers[provider]['models'].items()])
+
+# %% app.ipynb 30
+def update_model_choices(provider):
+    choices = get_model_choices(provider)
+    return gr.update(choices=choices,value=choices[0])
+
+# %% app.ipynb 31
+def get_voice_choices(provider, model):
+    return sorted([(v['name'],v['id']) for v in providers[provider]['voices'].values()])
+
+# %% app.ipynb 32
+def update_voice_choices(provider, model):
+    choices = get_voice_choices(provider, model)
+    return gr.update(choices=choices,value=choices[0])
+
+# %% app.ipynb 33
+with gr.Blocks(title='TTS', head='TTS', delete_cache=(3600,3600)) as app:
+    gr.Markdown("# TTS")
+    gr.Markdown("""Start typing below and then click **Go** to create the speech from your text.
+For requests longer than allowed by the API they will be broken into chunks automatically. [Spaces Link](https://matdmiller-tts-openai.hf.space/) | <a href="https://matdmiller-tts-openai.hf.space/" target="_blank">Spaces Link HTML</a>""")
     with gr.Row():
         input_text = gr.Textbox(max_lines=100, label="Enter text here")
     with gr.Row():
-        tts_model_dropdown = gr.Dropdown(value='tts-1',choices=tts_models, label='Model')
-        tts_voice_dropdown = gr.Dropdown(value='alloy',choices=tts_voices,label='Voice')
+        tts_provider_dropdown = gr.Dropdown(value=DEFAULT_PROVIDER,choices=[(v,k) for k,v in providers.items()], label='Provider')
+        tts_model_dropdown = gr.Dropdown(value=DEFAULT_MODEL,choices=get_model_choices(DEFAULT_PROVIDER), label='Model')
+        tts_voice_dropdown = gr.Dropdown(value=DEFAULT_VOICE,choices=get_voice_choices(DEFAULT_PROVIDER, DEFAULT_MODEL),label='Voice')
         input_text_length = gr.Label(label="Number of characters")
         generation_cost = gr.Label(label="Generation cost")
+    with gr.Row():
         output_audio = gr.Audio()
+
+    #input_text 
     input_text.input(fn=get_input_text_len, inputs=input_text, outputs=input_text_length)
-    input_text.input(fn=get_generation_cost, inputs=[input_text,tts_model_dropdown], outputs=generation_cost)
-    tts_model_dropdown.input(fn=get_generation_cost, inputs=[input_text,tts_model_dropdown], outputs=generation_cost)
+    input_text.input(fn=get_generation_cost, 
+                     inputs=[input_text,tts_model_dropdown,tts_provider_dropdown, tts_provider_dropdown], 
+                     outputs=tts_voice_dropdown)
+
+    tts_provider_dropdown.change(fn=update_model_choices, inputs=[tts_provider_dropdown], 
+                                 outputs=tts_model_dropdown)
+    tts_provider_dropdown.change(fn=update_voice_choices, inputs=[tts_provider_dropdown, tts_model_dropdown], 
+                                 outputs=tts_voice_dropdown)
+    
+    tts_model_dropdown.change(fn=get_generation_cost, 
+                              inputs=[input_text,tts_model_dropdown,tts_provider_dropdown], outputs=generation_cost)
+    
     go_btn = gr.Button("Go")
-    go_btn.click(fn=create_speech2, inputs=[input_text, tts_model_dropdown, tts_voice_dropdown], outputs=[output_audio])
+    go_btn.click(fn=create_speech, 
+                 inputs=[input_text, tts_provider_dropdown, tts_model_dropdown, tts_voice_dropdown], 
+                 outputs=[output_audio])
+    
     clear_btn = gr.Button('Clear')
     clear_btn.click(fn=lambda: '', outputs=input_text)
 
-    gr.LoginButton()
-    m = gr.Markdown('')
-    app.load(authorized, None, m)
+    if REQUIRE_AUTH:
+        gr.LoginButton()
+        m = gr.Markdown('')
+        app.load(verify_authorization, None, m)
     
 
-# %% app.ipynb 18
+# %% app.ipynb 34
 # launch_kwargs = {'auth':('username',GRADIO_PASSWORD),
 #                  'auth_message':'Please log in to Mat\'s TTS App with username: username and password.'}
 launch_kwargs = {}
 queue_kwargs = {'default_concurrency_limit':10}
 
-# %% app.ipynb 20
+# %% app.ipynb 36
 #.py launch
 if __name__ == "__main__":
     app.queue(**queue_kwargs)

requirements.txt

@@ -1,4 +1,5 @@
-openai==1.25.1
-gradio==4.28.3
+openai==1.34.0
+cartesia==0.1.1
+gradio==4.36.1
 pydub==0.25.1
-tenacity==8.2.3
+tenacity==8.3.0