11Labs_TTS_Colab_Shere.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2P5x4CzE-kLi"
      },
      "source": [
        "# ElevenLabs Python Infinite TTS API Google Colab - 11Labs_TTS_Colab\n",
        "\n",
        "GitHub: [https://github.com/elevenlabs/elevenlabs-python](https://github.com/elevenlabs/elevenlabs-python)\n",
        "\n",
        "Website: [https://elevenlabs.io/](https://elevenlabs.io/)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F_qo6WmJDeVv"
      },
      "source": [
        "# 1. Konfiguracja Wstępna✅"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "235UiEgkOYrk"
      },
      "outputs": [],
      "source": [
        "# @title 1.1 Instalacja Zależności { run: \"auto\" }\n",
        "\n",
        "!pip install elevenlabs -U\n",
        "!pip install rich -U\n",
        "!pip install pysrt -U\n",
        "!pip install pydub -U\n",
        "!pip install nest_asyncio -U\n",
        "\n",
        "#===============================================================================\n",
        "# ExecutionTimer - Mierzenie Czasu\n",
        "\"\"\"\n",
        "    Module execution_timer provides an ExecutionTimer class\n",
        "        to measure the execution time of a code block.\n",
        "    It offers two usage options: as a context manager and as a decorator.\n",
        "\n",
        "    * Example usage as a context manager:\n",
        "        with ExecutionTimer():\n",
        "            main()\n",
        "\n",
        "    * Example usage as a decorator:\n",
        "        @execution_timer\n",
        "        def main():\n",
        "            # Code block to measure execution time\n",
        "\"\"\"\n",
        "\n",
        "from datetime import datetime\n",
        "from time import perf_counter_ns\n",
        "from dataclasses import dataclass\n",
        "from rich.console import Console\n",
        "\n",
        "\n",
        "@dataclass(slots=True)\n",
        "class ExecutionTimer:\n",
        "    \"\"\"\n",
        "        ExecutionTimer is a context manager that measures the execution time of a code block.\n",
        "        It captures the start time, end time, and duration of the code block.\n",
        "    \"\"\"\n",
        "\n",
        "    start_date: datetime = None\n",
        "    end_date: datetime = None\n",
        "    start_time_ns: int = None\n",
        "    end_time_ns: int = None\n",
        "    console: Console = Console()\n",
        "\n",
        "    def __post_init__(self):\n",
        "        self.start_date = datetime.now()\n",
        "        self.start_time_ns = perf_counter_ns()\n",
        "\n",
        "    def __enter__(self) -> 'ExecutionTimer':\n",
        "        return self\n",
        "\n",
        "    def __exit__(self, exc_type, exc_val, exc_tb):\n",
        "        try:\n",
        "            self.end_date = datetime.now()\n",
        "            self.end_time_ns = perf_counter_ns()\n",
        "            self.display_time()\n",
        "        except AttributeError:\n",
        "            print('An error occurred: __exit__')\n",
        "\n",
        "    @staticmethod\n",
        "    def current_datetime(date: datetime) -> str:\n",
        "        \"\"\"\n",
        "            Formats a datetime object as a string in the format 'YYYY-MM-DD HH:MM:SS'.\n",
        "        \"\"\"\n",
        "\n",
        "        return f'[yellow]{date.year}-{date.month:02d}-{date.day:02d}' \\\n",
        "               f' [white bold]{date.hour:02d}:{date.minute:02d}:{date.second:02d}'\n",
        "\n",
        "    def calculate_duration(self) -> str:\n",
        "        \"\"\"\n",
        "            Calculates the duration of the code block in hours, minutes, seconds, milliseconds,\n",
        "            microseconds, and nanoseconds.\n",
        "        \"\"\"\n",
        "\n",
        "        duration_ns: int = self.end_time_ns - self.start_time_ns\n",
        "        duration_s, duration_ns = map(int, divmod(duration_ns, 1_000_000_000))\n",
        "        duration_ms, duration_ns = map(int, divmod(duration_ns, 1_000_000))\n",
        "        duration_us, duration_ns = map(int, divmod(duration_ns, 1_000))\n",
        "\n",
        "        hours, remainder = map(int, divmod(duration_s, 3600))\n",
        "        minutes, seconds = map(int, divmod(remainder, 60))\n",
        "\n",
        "        return f'[white bold]{hours:02d}:{minutes:02d}:{seconds:02d}:' \\\n",
        "               f'{duration_ms:03d}:{duration_us:03d}:{duration_ns:03d}'\n",
        "\n",
        "    def calculate_duration_alt(self) -> tuple[float, ...]:\n",
        "        \"\"\"\n",
        "            Calculates the duration of the code block in hours, minutes, and seconds\n",
        "            using an alternative method.\n",
        "        \"\"\"\n",
        "\n",
        "        duration_ns: int = self.end_time_ns - self.start_time_ns\n",
        "        hours_alt: float = duration_ns / 1_000_000_000 / 60 / 60\n",
        "        minutes_alt: float = duration_ns / 1_000_000_000 / 60\n",
        "        seconds_alt: float = duration_ns / 1_000_000_000\n",
        "\n",
        "        return hours_alt, minutes_alt, seconds_alt\n",
        "\n",
        "    def display_time(self):\n",
        "        \"\"\"\n",
        "            Displays the start date, end date, and duration of the code block execution.\n",
        "        \"\"\"\n",
        "\n",
        "        start_date_str: str = self.current_datetime(self.start_date)\n",
        "        end_date_str: str = self.current_datetime(self.end_date)\n",
        "        duration: str = self.calculate_duration()\n",
        "        hours_alt, minutes_alt, seconds_alt = map(\n",
        "            float, self.calculate_duration_alt())\n",
        "\n",
        "        self.console.print('\\n[bold white]╚═══════════ EXECUTION TIME ═══════════╝')\n",
        "        self.console.print('[bold bright_yellow]        YYYY-MM-DD HH:MM:SS:ms :µs :ns')\n",
        "        self.console.print(f'[bright_red bold][[bold white]START[bright_red bold]] {start_date_str}')\n",
        "        self.console.print(f'[bright_red bold][[bold white]END[bright_red bold]]   {end_date_str}')\n",
        "        self.console.print(f'[bright_red bold][[bold white]TIME[bright_red bold]]  [bold bright_yellow]YYYY-MM-DD {duration}')\n",
        "        self.console.print('[bright_red bold]                   ^^^^^^^^^^^^')\n",
        "        self.console.print(f'[bright_red bold][[bold white]TIME[bright_red bold]]  [white bold]{hours_alt:.9f} hours')\n",
        "        self.console.print(f'[bright_red bold][[bold white]TIME[bright_red bold]]  [white bold]{minutes_alt:.9f} minutes')\n",
        "        self.console.print(f'[bright_red bold][[bold white]TIME[bright_red bold]]  [white bold]{seconds_alt:.9f} seconds')\n",
        "\n",
        "\n",
        "def execution_timer(func):\n",
        "    \"\"\"\n",
        "        Decorator that measures the execution time of a function using ExecutionTimer.\n",
        "    \"\"\"\n",
        "\n",
        "    def wrapper(*args, **kwargs):\n",
        "        with ExecutionTimer():\n",
        "            result = func(*args, **kwargs)\n",
        "        return result\n",
        "\n",
        "    return wrapper"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Glie6PDQAmrr"
      },
      "outputs": [],
      "source": [
        "# @title 1.2.1 Zamontuj Google Drive i Stwórz Katalog: 11Labs_TTS_Colab { run: \"auto\" }\n",
        "import os\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "# Ścieżka do katalogu, który chcesz utworzyć\n",
        "google_drive_path = '/content/drive/MyDrive/11Labs_TTS_Colab/'\n",
        "# google_drive_path = '/content/drive/Shareddrives/Dysk_0/11Labs_TTS_Colab/'\n",
        "\n",
        "# Tworzenie katalogu, jeśli nie istnieje\n",
        "if not os.path.exists(google_drive_path):\n",
        "    os.makedirs(google_drive_path)\n",
        "    print(f\"Utworzono katalog: {google_drive_path}\")\n",
        "else:\n",
        "    print(f\"Katalog już istnieje: {google_drive_path}\")\n",
        "\n",
        "%cd /content/drive/MyDrive/11Labs_TTS_Colab/\n",
        "print(f\"Przejście do: {google_drive_path}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tAmpIC0aEK2L"
      },
      "source": [
        "***lub***"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "p-3lkg0EMwqt"
      },
      "outputs": [],
      "source": [
        "# @title 1.2.2 Zamontuj Repozytorium GitHub 11Labs_TTS_Colab { run: \"auto\" }\n",
        "import os\n",
        "\n",
        "# Twój Personal Access Token\n",
        "# https://github.com/settings/tokens\n",
        "token = 'YOU_token' #@param {type:\"string\"}\n",
        "\n",
        "# Adres URL repozytorium\n",
        "repo_url = 'https://github.com/YOU/11Labs_TTS_Colab.git' #@param {type:\"string\"}\n",
        "\n",
        "# Ścieżka do folderu, w którym chcesz umieścić repozytorium\n",
        "github_repo_path = '/content/11Labs_TTS_Colab/'\n",
        "\n",
        "# Konstrukcja URL z tokenem autoryzacyjnym\n",
        "auth_repo_url = repo_url.replace('https://', f'https://{token}@')\n",
        "\n",
        "# Użycie git clone z autoryzacją\n",
        "if not os.path.exists(github_repo_path):\n",
        "    !git clone $auth_repo_url $github_repo_path\n",
        "    print(f\"Utworzono katalog: {github_repo_path}\")\n",
        "else:\n",
        "    print(f\"Katalog już istnieje: {github_repo_path}\")\n",
        "\n",
        "\n",
        "# Wysyłanie zmian do repozytorium\n",
        "%cd /content/11Labs_TTS_Colab/\n",
        "print(f\"Przejście do: {github_repo_path}\")\n",
        "\n",
        "# Ustawienie konfiguracji dla Git\n",
        "global_email = \"YOU_email\"  #@param {type:\"string\"}\n",
        "global_name = \"YOU_user_name\"  #@param {type:\"string\"}\n",
        "!git config --global user.email \"{global_email}\"\n",
        "!git config --global user.name \"{global_name}\"\n",
        "print(\"Konfiguracja użytkownika Git zakończona!\")\n",
        "\n",
        "# Wysyłanie zmian do repozytorium\n",
        "# try:\n",
        "#     print(\"Wysyłanie zmian do repozytorium:\")\n",
        "#     !git add .\n",
        "#     !git commit -m \"Opis zmian\"\n",
        "#     !git push origin main\n",
        "#     print(\"Zmiany zostały wysłane do repozytorium.\")\n",
        "# except Exception as e:\n",
        "#     print(\"Wystąpił błąd podczas wysyłania zmian:\", e)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "59b9btf13ObF"
      },
      "source": [
        "# 2. ElevenLabs Infinite TTS API ✅"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "0XzM0hyVfXAt"
      },
      "outputs": [],
      "source": [
        "# @title 2.1 API Key Manager - Dodaj / Usuń / Zapisz Klucze API Do Google Drive ✅ { run: \"auto\" }\n",
        "import os\n",
        "import json\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import display, HTML\n",
        "import requests\n",
        "import subprocess\n",
        "\n",
        "#===============================================================================\n",
        "# Button CSS\n",
        "display(HTML('''\n",
        "<style>\n",
        "    .widget-button {\n",
        "        font-weight: bold !important;\n",
        "    }\n",
        "    .widget-button.jupyter-widgets.widget-button.mod-active,\n",
        "    .widget-button:active {\n",
        "        background-color: #2d2e2e;\n",
        "    }\n",
        "    .widget-toggle-button {\n",
        "        font-weight: bold !important;\n",
        "    }\n",
        "    .widget-toggle-button.jupyter-widgets.widget-toggle-button.mod-active,\n",
        "    .widget-toggle-button:active {\n",
        "        background-color: #2d2e2e;\n",
        "    }\n",
        "</style>\n",
        "'''))\n",
        "#===============================================================================\n",
        "\n",
        "api_keys = []\n",
        "\n",
        "class APIKeyManager:\n",
        "    def __init__(self, directory_path, file_name):\n",
        "        self.directory_path = directory_path\n",
        "        self.file_name = file_name\n",
        "        self.file_path = os.path.join(directory_path, file_name)\n",
        "        self.api_keys = self.load_api_keys()\n",
        "        self.key_info_output = widgets.Output()\n",
        "\n",
        "    def load_api_keys(self):\n",
        "        try:\n",
        "            with open(self.file_path, 'r') as file:\n",
        "                return json.load(file)\n",
        "        except FileNotFoundError:\n",
        "            return []\n",
        "\n",
        "    def save_api_keys(self, keys):\n",
        "        with open(self.file_path, 'w') as file:\n",
        "            json.dump(keys, file, indent=4)\n",
        "\n",
        "    def call_api_and_calculate_remaining_characters(self, api_key):\n",
        "        try:\n",
        "            url = \"https://api.elevenlabs.io/v1/user\"\n",
        "            headers = {\n",
        "                \"Accept\": \"application/json\",\n",
        "                \"xi-api-key\": api_key\n",
        "            }\n",
        "            response = requests.get(url, headers=headers)\n",
        "            response_data = response.json()\n",
        "            character_limit = response_data['subscription']['character_limit']\n",
        "            character_count = response_data['subscription']['character_count']\n",
        "            return character_limit - character_count\n",
        "        except (requests.exceptions.RequestException, KeyError, json.JSONDecodeError) as e:\n",
        "            print(\"Wystąpił błąd podczas wywoływania API:\", e)\n",
        "            return None\n",
        "\n",
        "    def update_and_save_remaining_characters(self, api_key):\n",
        "        if api_key is None:\n",
        "            return\n",
        "        try:\n",
        "            remaining_characters = self.call_api_and_calculate_remaining_characters(api_key)\n",
        "            if remaining_characters is not None:\n",
        "                for key in self.api_keys:\n",
        "                    if key['key'] == api_key:\n",
        "                        key['remaining_characters'] = remaining_characters\n",
        "                        break\n",
        "                self.save_api_keys(self.api_keys)\n",
        "        except Exception as e:\n",
        "            print(\"Wystąpił błąd podczas aktualizowania pozostałych znaków:\", e)\n",
        "\n",
        "    def generate_new_id(self):\n",
        "        return max(key['id'] for key in self.api_keys) + 1 if self.api_keys else 1\n",
        "\n",
        "    def execute_action(self, button):\n",
        "        selected_action = self.action_radio.value\n",
        "        if selected_action == 'Dodaj klucz API':\n",
        "            new_key = self.new_key_text.value\n",
        "            new_description = self.new_description_text.value\n",
        "            if new_key and new_description:\n",
        "                try:\n",
        "                    if any(key['key'] == new_key or key['description'] == new_description for key in self.api_keys):\n",
        "                        print(\"Klucz API lub opis się powtarzają. Proszę wybrać unikalne wartości.\")\n",
        "                    else:\n",
        "                        new_id = self.generate_new_id()\n",
        "                        new_api_key = {\"id\": new_id, \"key\": new_key, \"description\": new_description}\n",
        "                        self.api_keys.append(new_api_key)\n",
        "                        self.save_api_keys(self.api_keys)\n",
        "                        print(\"Nowy klucz API został dodany.\")\n",
        "                        self.update_and_save_remaining_characters(new_key)\n",
        "                        self.key_info_dropdown.options = [\n",
        "                        (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key) for key in self.api_keys]\n",
        "                        for option in self.key_info_dropdown.options:\n",
        "                            if option[1]['id'] == new_id:\n",
        "                                self.key_info_dropdown.value = option[1]\n",
        "                                break\n",
        "                        self.display_key_info(self.key_info_dropdown.value)\n",
        "                except Exception as e:\n",
        "                    print(\"Wystąpił błąd podczas dodawania klucza API:\", e)\n",
        "        elif selected_action == 'Usuń klucz API':\n",
        "            if self.key_info_dropdown.value is not None:\n",
        "                try:\n",
        "                    selected_key = self.key_info_dropdown.value\n",
        "                    key_id = selected_key['id']\n",
        "                    for key in self.api_keys:\n",
        "                        if key['id'] == key_id:\n",
        "                            self.api_keys.remove(key)\n",
        "                            self.save_api_keys(self.api_keys)\n",
        "                            print(f\"Klucz API o ID '{key_id}' został usunięty.\")\n",
        "                            self.key_info_dropdown.options = [\n",
        "                                (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key) for key in self.api_keys]\n",
        "                            self.key_info_dropdown.value = None\n",
        "                            self.key_info_output.clear_output()\n",
        "                            break\n",
        "                except Exception as e:\n",
        "                    print(\"Wystąpił błąd podczas usuwania klucza API:\", e)\n",
        "            else:\n",
        "                print(\"Wybierz klucz do usunięcia.\")\n",
        "\n",
        "    def display_key_info(self, key):\n",
        "        self.key_info_output.clear_output()\n",
        "        with self.key_info_output:\n",
        "            print(f\"ID: {key['id']}\")\n",
        "            print(f\"Key: {key['key']}\")\n",
        "            print(f\"Description: {key['description']}\")\n",
        "            if 'remaining_characters' in key:\n",
        "                print(f\"Remaining Characters: {key['remaining_characters']}\")\n",
        "\n",
        "    def on_key_info_dropdown_change(self, change):\n",
        "        if change['new'] is not None:\n",
        "            self.display_key_info(change['new'])\n",
        "            self.update_and_save_remaining_characters(change['new']['key'])\n",
        "            current_key = self.key_info_dropdown.value\n",
        "            self.key_info_dropdown.options = [\n",
        "                (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key)\n",
        "                for key in self.api_keys]\n",
        "            self.key_info_dropdown.value = current_key\n",
        "            self.display_key_info(current_key)\n",
        "\n",
        "    def start(self):\n",
        "        self.action_radio = widgets.RadioButtons(\n",
        "            options=['Dodaj klucz API', 'Usuń klucz API'],\n",
        "            description='Akcja:'\n",
        "        )\n",
        "\n",
        "        self.new_key_text = widgets.Text(description='Klucz API:')\n",
        "        self.new_description_text = widgets.Text(description='Opis:')\n",
        "\n",
        "        self.key_info_dropdown = widgets.Dropdown(\n",
        "            options=[(f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key)\n",
        "                    for key in self.api_keys if 'remaining_characters' in key],\n",
        "            description='Wybierz:',\n",
        "            value=self.api_keys[0] if self.api_keys else None\n",
        "        )\n",
        "\n",
        "        self.key_info_dropdown.observe(self.on_key_info_dropdown_change, 'value')\n",
        "\n",
        "        self.key_info_output = widgets.Output()\n",
        "\n",
        "        self.execute_button = widgets.Button(\n",
        "            description='Wykonaj',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        self.execute_button.on_click(self.execute_action)\n",
        "\n",
        "        display(self.action_radio)\n",
        "        display(self.new_key_text)\n",
        "        display(self.new_description_text)\n",
        "        display(self.key_info_dropdown)\n",
        "        display(self.key_info_output)\n",
        "        display(self.execute_button)\n",
        "\n",
        "        if self.api_keys:\n",
        "            self.display_key_info(self.api_keys[0])\n",
        "            for key in self.api_keys:\n",
        "                self.update_and_save_remaining_characters(key['key'])\n",
        "        self.on_key_info_dropdown_change({'new': self.key_info_dropdown.value})\n",
        "\n",
        "    def get_api_keys(self):\n",
        "        global api_keys\n",
        "        api_keys = self.api_keys\n",
        "\n",
        "def main(directory_path):\n",
        "    file_name = 'elevenlabs_api_keys.json'\n",
        "\n",
        "    display(HTML('<h1>API Key Manager - Google Drive</h1>'))\n",
        "    manager = APIKeyManager(directory_path, file_name)\n",
        "    manager.start()\n",
        "    manager.get_api_keys()\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main(google_drive_path)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fk6m45LEE9Og"
      },
      "source": [
        "***lub***"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "fmysSSd47yb2"
      },
      "outputs": [],
      "source": [
        "# @title 2.2 API Key Manager - Dodaj / Usuń / Zapisz Klucze API Oraz Pliki Audio Do Repozytorium GitHub ✅ { run: \"auto\" }\n",
        "import os\n",
        "import json\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import display, HTML\n",
        "import requests\n",
        "import subprocess\n",
        "\n",
        "#===============================================================================\n",
        "# Button CSS\n",
        "display(HTML('''\n",
        "<style>\n",
        "    .widget-button {\n",
        "        font-weight: bold !important;\n",
        "    }\n",
        "    .widget-button.jupyter-widgets.widget-button.mod-active,\n",
        "    .widget-button:active {\n",
        "        background-color: #2d2e2e;\n",
        "    }\n",
        "    .widget-toggle-button {\n",
        "        font-weight: bold !important;\n",
        "    }\n",
        "    .widget-toggle-button.jupyter-widgets.widget-toggle-button.mod-active,\n",
        "    .widget-toggle-button:active {\n",
        "        background-color: #2d2e2e;\n",
        "    }\n",
        "</style>\n",
        "'''))\n",
        "#===============================================================================\n",
        "\n",
        "api_keys = []\n",
        "\n",
        "class APIKeyManager:\n",
        "    def __init__(self, token, repo_url, directory_path, auth_repo_url, file_name):\n",
        "        self.token = token\n",
        "        self.repo_url = repo_url\n",
        "        self.directory_path = directory_path\n",
        "        self.auth_repo_url = auth_repo_url\n",
        "        self.file_name = file_name\n",
        "        self.file_path = os.path.join(directory_path, file_name)\n",
        "        self.api_keys = self.load_api_keys()\n",
        "        self.key_info_output = widgets.Output()\n",
        "\n",
        "    def update_github_repo(self, commit_msg):\n",
        "        try:\n",
        "            os.chdir(self.directory_path)\n",
        "            subprocess.run([\"git\", \"add\", \".\"])\n",
        "            subprocess.run([\"git\", \"commit\", \"-m\", commit_msg])\n",
        "            subprocess.run([\"git\", \"push\", \"origin\", \"main\"])\n",
        "            print(\"Repozytorium zostało zaktualizowane na GitHubie.\")\n",
        "        except Exception as e:\n",
        "            print(\"Wystąpił błąd podczas aktualizowania repozytorium:\", e)\n",
        "\n",
        "    def load_api_keys(self):\n",
        "        try:\n",
        "            with open(self.file_path, 'r') as file:\n",
        "                return json.load(file)\n",
        "        except FileNotFoundError:\n",
        "            return []\n",
        "\n",
        "    def save_api_keys(self, keys):\n",
        "        with open(self.file_path, 'w') as file:\n",
        "            json.dump(keys, file, indent=4)\n",
        "\n",
        "    def call_api_and_calculate_remaining_characters(self, api_key):\n",
        "        try:\n",
        "            url = \"https://api.elevenlabs.io/v1/user\"\n",
        "            headers = {\n",
        "                \"Accept\": \"application/json\",\n",
        "                \"xi-api-key\": api_key\n",
        "            }\n",
        "            response = requests.get(url, headers=headers)\n",
        "            response_data = response.json()\n",
        "            character_limit = response_data['subscription']['character_limit']\n",
        "            character_count = response_data['subscription']['character_count']\n",
        "            return character_limit - character_count\n",
        "        except (requests.exceptions.RequestException, KeyError, json.JSONDecodeError) as e:\n",
        "            print(\"Wystąpił błąd podczas wywoływania API:\", e)\n",
        "            return None\n",
        "\n",
        "    def update_and_save_remaining_characters(self, api_key):\n",
        "        if api_key is None:\n",
        "            return\n",
        "        try:\n",
        "            remaining_characters = self.call_api_and_calculate_remaining_characters(api_key)\n",
        "            if remaining_characters is not None:\n",
        "                for key in self.api_keys:\n",
        "                    if key['key'] == api_key:\n",
        "                        key['remaining_characters'] = remaining_characters\n",
        "                        break\n",
        "                self.save_api_keys(self.api_keys)\n",
        "        except Exception as e:\n",
        "            print(\"Wystąpił błąd podczas aktualizowania pozostałych znaków:\", e)\n",
        "\n",
        "    def generate_new_id(self):\n",
        "        return max(key['id'] for key in self.api_keys) + 1 if self.api_keys else 1\n",
        "\n",
        "    def execute_action(self, button):\n",
        "        selected_action = self.action_radio.value\n",
        "        if selected_action == 'Dodaj klucz API':\n",
        "            new_key = self.new_key_text.value\n",
        "            new_description = self.new_description_text.value\n",
        "            if new_key and new_description:\n",
        "                try:\n",
        "                    if any(key['key'] == new_key or key['description'] == new_description for key in self.api_keys):\n",
        "                        print(\"Klucz API lub opis się powtarzają. Proszę wybrać unikalne wartości.\")\n",
        "                    else:\n",
        "                        new_id = self.generate_new_id()\n",
        "                        new_api_key = {\"id\": new_id, \"key\": new_key, \"description\": new_description}\n",
        "                        self.api_keys.append(new_api_key)\n",
        "                        self.save_api_keys(self.api_keys)\n",
        "                        print(\"Nowy klucz API został dodany.\")\n",
        "                        self.update_and_save_remaining_characters(new_key)\n",
        "                        self.key_info_dropdown.options = [\n",
        "                            (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key) for key in self.api_keys]\n",
        "                        for option in self.key_info_dropdown.options:\n",
        "                            if option[1]['id'] == new_id:\n",
        "                                self.key_info_dropdown.value = option[1]\n",
        "                                break\n",
        "                        self.display_key_info(self.key_info_dropdown.value)\n",
        "                    self.update_github_repo(\"Dodano klucz API\")\n",
        "                except Exception as e:\n",
        "                    print(\"Wystąpił błąd podczas dodawania klucza API:\", e)\n",
        "        elif selected_action == 'Usuń klucz API':\n",
        "            if self.key_info_dropdown.value is not None:\n",
        "                try:\n",
        "                    selected_key = self.key_info_dropdown.value\n",
        "                    key_id = selected_key['id']\n",
        "                    for key in self.api_keys:\n",
        "                        if key['id'] == key_id:\n",
        "                            self.api_keys.remove(key)\n",
        "                            self.save_api_keys(self.api_keys)\n",
        "                            print(f\"Klucz API o ID '{key_id}' został usunięty.\")\n",
        "                            self.key_info_dropdown.options = [\n",
        "                                (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key) for key in self.api_keys]\n",
        "                            self.key_info_dropdown.value = None\n",
        "                            self.key_info_output.clear_output()\n",
        "                            break\n",
        "                    self.update_github_repo(\"Usunięto klucz API\")\n",
        "                except Exception as e:\n",
        "                    print(\"Wystąpił błąd podczas usuwania klucza API:\", e)\n",
        "            else:\n",
        "                print(\"Wybierz klucz do usunięcia.\")\n",
        "\n",
        "\n",
        "    def display_key_info(self, key):\n",
        "        self.key_info_output.clear_output()\n",
        "        with self.key_info_output:\n",
        "            print(f\"ID: {key['id']}\")\n",
        "            print(f\"Key: {key['key']}\")\n",
        "            print(f\"Description: {key['description']}\")\n",
        "            if 'remaining_characters' in key:\n",
        "                print(f\"Remaining Characters: {key['remaining_characters']}\")\n",
        "\n",
        "    def on_key_info_dropdown_change(self, change):\n",
        "        if change['new'] is not None:\n",
        "            self.display_key_info(change['new'])\n",
        "            self.update_and_save_remaining_characters(change['new']['key'])\n",
        "            self.update_github_repo(\"Zaktualizowano dane klucza API\")\n",
        "            current_key = self.key_info_dropdown.value\n",
        "            self.key_info_dropdown.options = [\n",
        "                (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key)\n",
        "                for key in self.api_keys]\n",
        "            self.key_info_dropdown.value = current_key\n",
        "            self.display_key_info(current_key)\n",
        "\n",
        "    def start(self):\n",
        "        self.action_radio = widgets.RadioButtons(\n",
        "            options=['Dodaj klucz API', 'Usuń klucz API'],\n",
        "            description='Akcja:'\n",
        "        )\n",
        "\n",
        "        self.new_key_text = widgets.Text(description='Klucz API:')\n",
        "        self.new_description_text = widgets.Text(description='Opis:')\n",
        "\n",
        "        self.key_info_dropdown = widgets.Dropdown(\n",
        "            options=[(f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key)\n",
        "                    for key in self.api_keys if 'remaining_characters' in key],\n",
        "            description='Wybierz:',\n",
        "            value=self.api_keys[0] if self.api_keys else None\n",
        "        )\n",
        "\n",
        "        self.key_info_dropdown.observe(self.on_key_info_dropdown_change, 'value')\n",
        "\n",
        "        self.key_info_output = widgets.Output()\n",
        "\n",
        "        self.execute_button = widgets.Button(\n",
        "            description='Wykonaj',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        self.execute_button.on_click(self.execute_action)\n",
        "\n",
        "        display(self.action_radio)\n",
        "        display(self.new_key_text)\n",
        "        display(self.new_description_text)\n",
        "        display(self.key_info_dropdown)\n",
        "        display(self.key_info_output)\n",
        "        display(self.execute_button)\n",
        "\n",
        "        if self.api_keys:\n",
        "            self.display_key_info(self.api_keys[0])\n",
        "            for key in self.api_keys:\n",
        "                self.update_and_save_remaining_characters(key['key'])\n",
        "\n",
        "        self.on_key_info_dropdown_change({'new': self.key_info_dropdown.value})\n",
        "        self.update_github_repo(\"Automatyczna aktualizacja pozostałych znaków\")\n",
        "\n",
        "    def get_api_keys(self):\n",
        "        global api_keys\n",
        "        api_keys = self.api_keys\n",
        "\n",
        "def main(token, repo_url, github_repo_path, auth_repo_url):\n",
        "    directory_path = github_repo_path\n",
        "    file_name = 'elevenlabs_api_keys.json'\n",
        "\n",
        "    display(HTML('<h1>API Key Manager - Repozytorium GitHub</h1>'))\n",
        "    manager = APIKeyManager(token, repo_url, directory_path, auth_repo_url, file_name)\n",
        "    manager.start()\n",
        "    manager.get_api_keys()\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main(token, repo_url, github_repo_path, auth_repo_url)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "D0b_lPN_x_lF"
      },
      "outputs": [],
      "source": [
        "# @title ElevenLabs Infinite TTS API Generator { run: \"auto\" }\n",
        "\n",
        "import ipywidgets as widgets\n",
        "import IPython.display as ipd\n",
        "import requests\n",
        "import os\n",
        "import zipfile\n",
        "from elevenlabs import voices, set_api_key, Models\n",
        "from IPython.display import clear_output, display, HTML\n",
        "from google.colab import files\n",
        "\n",
        "\n",
        "class TTSGenerator:\n",
        "    def __init__(self):\n",
        "        self.output_dir = 'output_audio'\n",
        "        self.default_path = \"/content/\"\n",
        "        self.google_drive_path = '/content/drive/MyDrive/11Labs_TTS_Colab/'\n",
        "        self.github_repo_path = '/content/11Labs_TTS_Colab/'\n",
        "        self.available_paths = self.get_available_paths()\n",
        "        self.folder_radio = self.create_folder_radio()\n",
        "        self.folder_radio.observe(self.update_folder, 'value')\n",
        "        self.api_key_widget = self.create_api_key_widget()\n",
        "        self.api_key_widget.observe(self.set_api_and_refresh, names='value')\n",
        "        self.audio_files = []\n",
        "        self.url = None\n",
        "        self.headers = None\n",
        "\n",
        "        os.chdir(self.default_path)\n",
        "\n",
        "    def get_available_paths(self):\n",
        "        available_paths = []\n",
        "        if os.path.exists(self.default_path):\n",
        "            available_paths.append('Google Colab')\n",
        "        if self.google_drive_path is not None:\n",
        "            available_paths.append('Google Drive')\n",
        "        if self.github_repo_path is not None:\n",
        "            available_paths.append('GitHub')\n",
        "        return available_paths\n",
        "\n",
        "    def create_folder_radio(self):\n",
        "        return widgets.RadioButtons(\n",
        "            options=self.available_paths,\n",
        "            description='Lokalizacja:',\n",
        "            disabled=False\n",
        "        )\n",
        "\n",
        "    def update_folder(self, change):\n",
        "        new_path = self.default_path\n",
        "        if change.new == 'Google Drive' and self.google_drive_path is not None:\n",
        "            new_path = self.google_drive_path\n",
        "        if change.new == 'GitHub' and self.github_repo_path is not None:\n",
        "            new_path = self.github_repo_path\n",
        "        os.chdir(new_path)\n",
        "        os.makedirs(self.output_dir, exist_ok=True)\n",
        "        self.audio_files = self.refresh_output_audio_list(self.output_dir)\n",
        "        self.selected_audio.options = self.audio_files\n",
        "\n",
        "    def create_api_key_widget(self):\n",
        "        sorted_api_keys = sorted(api_keys, key=lambda k: k['id'], reverse=False)\n",
        "        first_valid_key = next((key for key in sorted_api_keys if key.get('remaining_characters', 0) > 0), None)\n",
        "        return widgets.Dropdown(\n",
        "            options=[(f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key['key']) for key in sorted_api_keys],\n",
        "            description=\"Klucz API:\",\n",
        "            value=first_valid_key['key'] if first_valid_key else None\n",
        "        )\n",
        "\n",
        "    def set_api_and_refresh(self, change):\n",
        "        try:\n",
        "            selected_key = next(\n",
        "                key for key in api_keys if key['key'] == self.api_key_widget.value)\n",
        "            set_api_key(selected_key['key'])\n",
        "            self.refresh_voices_and_clear_ui()\n",
        "        except Exception as e:\n",
        "            clear_output()\n",
        "            display(HTML('<h1>ElevenLabs TTS API Google Colab</h1>'))\n",
        "            display(self.api_key_widget)\n",
        "            display(HTML('<p style=\"color: red;\">Błąd: Nieprawidłowy klucz API</p>'))\n",
        "\n",
        "    def display_api_generator_header(self):\n",
        "        clear_output()\n",
        "        display(HTML('<h1>ElevenLabs Infinite TTS API Generator</h1>'))\n",
        "        set_api_key(self.api_key_widget.value)\n",
        "\n",
        "    def get_voice_options(self):\n",
        "        available_voices = voices()\n",
        "        return sorted([\n",
        "            (\n",
        "                f\"{voice.name} ({voice.category}) - {voice.labels['accent']}\" + (f\", {voice.labels['description']}\" if 'description' in voice.labels else \"\") +\n",
        "                f\", {voice.labels['age']}, {voice.labels['gender']}\" +\n",
        "                (f\", {voice.labels['use case']}\" if 'use case' in voice.labels else \"\"),\n",
        "                voice.voice_id\n",
        "            )\n",
        "            for voice in available_voices.voices\n",
        "        ])\n",
        "\n",
        "    def create_selected_voice_dropdown(self, voice_options):\n",
        "        return widgets.Dropdown(\n",
        "            options=voice_options,\n",
        "            description=\"Głos:\"\n",
        "        )\n",
        "\n",
        "    def display_selected_voice_preview(self, change):\n",
        "        selected_voice_id = change['new']  # Dodaj tę linijkę\n",
        "        with self.output_audio_widget:\n",
        "            self.output_audio_widget.clear_output()\n",
        "            selected_voice_id = change['new']\n",
        "            selected_voice = next((voice for voice in voices(\n",
        "            ).voices if voice.voice_id == selected_voice_id), None)\n",
        "            if selected_voice:\n",
        "                print(f\"Podgląd Głosu: {selected_voice.name}, VID: {selected_voice_id}\")\n",
        "                # Automatyczne odtwarzanie\n",
        "                # audio_display = ipd.Audio(\n",
        "                #     selected_voice.preview_url, autoplay=True)\n",
        "                audio_display = ipd.Audio(\n",
        "                    selected_voice.preview_url, autoplay=False)\n",
        "                display(audio_display)\n",
        "                if selected_voice.settings:\n",
        "                    self.stability_widget.value = selected_voice.settings.stability\n",
        "                    self.similarity_boost_widget.value = selected_voice.settings.similarity_boost\n",
        "\n",
        "    def setup_voice_change_handler(self, selected_voice):\n",
        "        selected_voice.observe(\n",
        "            self.display_selected_voice_preview, names='value')\n",
        "        selected_voice.observe(lambda change: self.update_url_and_headers(\n",
        "            selected_voice), names='value')\n",
        "\n",
        "    def initialize_voice_settings(self, selected_voice):\n",
        "        self.update_url_and_headers(selected_voice)\n",
        "\n",
        "    def setup_selected_voice_dropdown(self):\n",
        "        voice_options = self.get_voice_options()\n",
        "        selected_voice = self.create_selected_voice_dropdown(voice_options)\n",
        "        self.setup_voice_change_handler(selected_voice)\n",
        "        self.initialize_voice_settings(selected_voice)\n",
        "        return selected_voice\n",
        "\n",
        "    def create_text_widget(self):\n",
        "        text_widget = widgets.Textarea(\n",
        "            value=\"OK\",\n",
        "            description=\"Tekst:\",\n",
        "            rows=5,\n",
        "            layout=widgets.Layout(width=\"90%\", height=\"150px\")\n",
        "        )\n",
        "\n",
        "        char_counter = widgets.Label(\n",
        "            value=f\"{len(text_widget.value)} / 2500\",\n",
        "            layout=widgets.Layout(margin='0 0 0 90px')  # Dodaj tę linijkę\n",
        "        )\n",
        "\n",
        "        def check_length(change):\n",
        "            if len(change.new) > 2500:\n",
        "                text_widget.value = change.new[:2500]\n",
        "            char_counter.value = f\"{len(text_widget.value)} / 2500\"\n",
        "\n",
        "        text_widget.observe(check_length, 'value')\n",
        "\n",
        "        return widgets.VBox([text_widget, char_counter])\n",
        "\n",
        "    def update_url_and_headers(self, selected_voice):\n",
        "        self.url = f\"https://api.elevenlabs.io/v1/text-to-speech/{selected_voice.value}\"\n",
        "        self.headers = {\n",
        "            \"Accept\": \"audio/mpeg\",\n",
        "            \"Content-Type\": \"application/json\",\n",
        "            \"xi-api-key\": self.api_key_widget.value\n",
        "        }\n",
        "\n",
        "    def create_model_name_to_id_mapping(self, models_list):\n",
        "        return {model.name: model.model_id for model in models_list.models}\n",
        "\n",
        "    def create_model_name_widget(self, models_list):\n",
        "        return widgets.Dropdown(\n",
        "            options=[model.name for model in models_list.models],\n",
        "            value=models_list.models[0].name,\n",
        "            description=\"Model:\"\n",
        "        )\n",
        "\n",
        "    def create_model_widgets(self):\n",
        "        models_list = Models.from_api()\n",
        "        model_name_to_id = self.create_model_name_to_id_mapping(models_list)\n",
        "        model_name_widget = self.create_model_name_widget(models_list)\n",
        "        return model_name_to_id, model_name_widget\n",
        "\n",
        "    def create_stability_widget(self):\n",
        "        return widgets.FloatSlider(\n",
        "            value=0.5,\n",
        "            min=0.0,\n",
        "            max=1.0,\n",
        "            step=0.01,\n",
        "            description=\"Stabilność:\"\n",
        "        )\n",
        "\n",
        "    def create_similarity_boost_widget(self):\n",
        "        return widgets.FloatSlider(\n",
        "            value=0.75,\n",
        "            min=0.0,\n",
        "            max=1.0,\n",
        "            step=0.01,\n",
        "            description=\"Podobność:\"\n",
        "        )\n",
        "\n",
        "    def create_style_widget(self):\n",
        "        return widgets.FloatSlider(\n",
        "            value=0.0,\n",
        "            min=0.0,\n",
        "            max=1.0,\n",
        "            step=0.01,\n",
        "            description=\"Styl:\"\n",
        "        )\n",
        "\n",
        "    def create_use_speaker_boost_widget(self):\n",
        "        return widgets.RadioButtons(\n",
        "            options=[(\"Tak\", True), (\"Nie\", False)],\n",
        "            value=True,\n",
        "            description=\"Przesilenie:\"\n",
        "        )\n",
        "\n",
        "    def create_unique_filename(self, output_dir, counter):\n",
        "        while True:\n",
        "            filename = os.path.join(output_dir, f\"{counter:05d}.mp3\")\n",
        "            if not os.path.exists(filename):\n",
        "                return filename\n",
        "            counter += 1\n",
        "\n",
        "    def refresh_output_audio_list(self, output_dir):\n",
        "        return sorted(\n",
        "            [\n",
        "                filename\n",
        "                for filename in os.listdir(output_dir)\n",
        "                if filename.endswith('.mp3')\n",
        "            ]\n",
        "        )\n",
        "\n",
        "    def download_audio(self, b, text_widget, model_name_widget, model_name_to_id, stability_widget,\n",
        "                      similarity_boost_widget, style_widget, use_speaker_boost_widget,\n",
        "                      selected_voice, selected_audio, url, headers, output_dir):\n",
        "\n",
        "        self.audio_files = self.refresh_output_audio_list(output_dir)\n",
        "\n",
        "        data = {\n",
        "            \"text\": text_widget.value,\n",
        "            \"model_id\": model_name_to_id[model_name_widget.value],\n",
        "            \"voice_settings\": {\n",
        "                \"stability\": stability_widget.value,\n",
        "                \"similarity_boost\": similarity_boost_widget.value,\n",
        "                \"style\": style_widget.value,\n",
        "                \"use_speaker_boost\": use_speaker_boost_widget.value\n",
        "            }\n",
        "        }\n",
        "\n",
        "        response = requests.post(url, json=data, headers=headers)\n",
        "\n",
        "        output_filename = self.create_unique_filename(\n",
        "            output_dir, len(self.audio_files) + 1)\n",
        "\n",
        "        with open(output_filename, 'wb') as f:\n",
        "            for chunk in response.iter_content(chunk_size=2048):\n",
        "                if chunk:\n",
        "                    f.write(chunk)\n",
        "\n",
        "        self.audio_files.append(os.path.basename(output_filename))\n",
        "        selected_audio.options = self.audio_files\n",
        "        selected_audio.value = [os.path.basename(output_filename)]\n",
        "\n",
        "    def display_selected_audio(self, change, output_dir, selected_audio, output_audio_widget):\n",
        "        with output_audio_widget:\n",
        "            output_audio_widget.clear_output()\n",
        "            selected_files = selected_audio.value\n",
        "            if len(selected_files) == 1:\n",
        "                filename = selected_files[0]\n",
        "                audio_path = os.path.join(output_dir, filename)\n",
        "                display(HTML(f'<h3>Plik: {filename}</h3>'))\n",
        "                # Automatyczne odtwarzanie\n",
        "                audio_display = ipd.Audio(audio_path, autoplay=True)\n",
        "                display(audio_display)\n",
        "            else:\n",
        "                for filename in selected_files:\n",
        "                    audio_path = os.path.join(output_dir, filename)\n",
        "                    display(HTML(f'<h3>Plik: {filename}</h3>'))\n",
        "                    audio_display = ipd.Audio(audio_path)\n",
        "                    display(audio_display)\n",
        "\n",
        "    def download_selected_audio(self, b, output_dir, selected_audio):\n",
        "        selected_files = selected_audio.value\n",
        "        zip_filename = os.path.join(output_dir, 'selected_audio.zip')\n",
        "        with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
        "            for filename in selected_files:\n",
        "                audio_path = os.path.join(output_dir, filename)\n",
        "                zipf.write(audio_path, os.path.basename(audio_path))\n",
        "        files.download(zip_filename)\n",
        "\n",
        "    def download_all_audio(self, b, output_dir, audio_files):\n",
        "        zip_filename = os.path.join(output_dir, 'all_audio.zip')\n",
        "        with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
        "            for filename in audio_files:\n",
        "                audio_path = os.path.join(output_dir, filename)\n",
        "                zipf.write(audio_path, os.path.basename(audio_path))\n",
        "        files.download(zip_filename)\n",
        "\n",
        "    def create_generating_button(self):\n",
        "        return widgets.Button(\n",
        "            description=\"Wygeneruj Audio\",\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width=\"300px\", height=\"30px\"))\n",
        "\n",
        "    def create_selected_audio(self):\n",
        "        audio_files = sorted([filename for filename in os.listdir(\n",
        "            'output_audio') if filename.endswith('.mp3')])\n",
        "        return widgets.SelectMultiple(\n",
        "            options=audio_files,\n",
        "            description='',\n",
        "            disabled=False\n",
        "        )\n",
        "\n",
        "    def create_download_buttons(self, output_dir, selected_audio, audio_files):\n",
        "        download_selected_button = widgets.Button(\n",
        "            description='Pobierz Zaznaczone',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px'))\n",
        "\n",
        "        download_all_button = widgets.Button(\n",
        "            description='Pobierz Wszystko',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px'))\n",
        "\n",
        "        download_selected_button.on_click(\n",
        "            lambda b: self.download_selected_audio(b, output_dir, selected_audio))\n",
        "        download_all_button.on_click(\n",
        "            lambda b: self.download_all_audio(b, output_dir, audio_files))\n",
        "\n",
        "        return download_selected_button, download_all_button\n",
        "\n",
        "    def refresh_voices_and_clear_ui(self):\n",
        "        os.makedirs(self.output_dir, exist_ok=True)\n",
        "        self.folder_radio.observe(self.update_folder, 'value')\n",
        "        self.display_api_generator_header()\n",
        "        self.selected_voice = self.setup_selected_voice_dropdown()\n",
        "\n",
        "        self.text_widget = self.create_text_widget()\n",
        "        self.model_name_to_id, self.model_name_widget = self.create_model_widgets()\n",
        "\n",
        "        self.stability_widget = self.create_stability_widget()\n",
        "        self.similarity_boost_widget = self.create_similarity_boost_widget()\n",
        "        self.style_widget = self.create_style_widget()\n",
        "        self.use_speaker_boost_widget = self.create_use_speaker_boost_widget()\n",
        "\n",
        "        self.selected_audio = self.create_selected_audio()\n",
        "\n",
        "        if os.path.exists(self.output_dir):\n",
        "            self.audio_files = self.refresh_output_audio_list(self.output_dir)\n",
        "            self.selected_audio.options = self.audio_files\n",
        "\n",
        "        self.audio_files = self.refresh_output_audio_list(self.output_dir)\n",
        "\n",
        "        self.generating_button = self.create_generating_button()\n",
        "\n",
        "        self.output_audio_widget = widgets.Output()\n",
        "        self.display_selected_voice_preview({'new': self.selected_voice.value})\n",
        "\n",
        "        self.selected_audio = self.create_selected_audio()\n",
        "\n",
        "        # Download buttons\n",
        "        self.download_selected_button, self.download_all_button = self.create_download_buttons(\n",
        "            self.output_dir, self.selected_audio, self.audio_files)\n",
        "\n",
        "        self.generating_button.on_click(\n",
        "            lambda b: self.download_audio(\n",
        "                b, self.text_widget.children[0], self.model_name_widget, self.model_name_to_id, self.stability_widget,\n",
        "                self.similarity_boost_widget, self.style_widget, self.use_speaker_boost_widget,\n",
        "                self.selected_voice, self.selected_audio, self.url, self.headers, self.output_dir\n",
        "            )\n",
        "        )\n",
        "\n",
        "        self.selected_audio.observe(\n",
        "            lambda change: self.display_selected_audio(\n",
        "                change, self.output_dir, self.selected_audio, self.output_audio_widget),\n",
        "            names='value'\n",
        "        )\n",
        "\n",
        "        #===============================================================================\n",
        "        # Button CSS\n",
        "        display(HTML('''\n",
        "        <style>\n",
        "            .widget-button {\n",
        "                font-weight: bold !important;\n",
        "            }\n",
        "            .widget-button.jupyter-widgets.widget-button.mod-active,\n",
        "            .widget-button:active {\n",
        "                background-color: #2d2e2e;\n",
        "            }\n",
        "            .widget-toggle-button {\n",
        "                font-weight: bold !important;\n",
        "            }\n",
        "            .widget-toggle-button.jupyter-widgets.widget-toggle-button.mod-active,\n",
        "            .widget-toggle-button:active {\n",
        "                background-color: #2d2e2e;\n",
        "            }\n",
        "        </style>\n",
        "        '''))\n",
        "        #===============================================================================\n",
        "\n",
        "        display(self.folder_radio,\n",
        "                self.api_key_widget,\n",
        "                self.selected_voice,\n",
        "                self.model_name_widget,\n",
        "                self.text_widget,\n",
        "                self.stability_widget,\n",
        "                self.similarity_boost_widget,\n",
        "                self.style_widget,\n",
        "                self.use_speaker_boost_widget,\n",
        "                self.generating_button,\n",
        "                self.selected_audio,\n",
        "                self.output_audio_widget,\n",
        "                self.download_selected_button,\n",
        "                self.download_all_button)\n",
        "\n",
        "def main():\n",
        "    tts_generator = TTSGenerator()\n",
        "    display(tts_generator.api_key_widget)\n",
        "    tts_generator.refresh_voices_and_clear_ui()\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jLcAcRgpzOez"
      },
      "source": [
        "# 3. ElevenLabs Infinite TTS API - Anime Lektor PL ✅"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "KarIYU5XM9D9"
      },
      "outputs": [],
      "source": [
        "# @title ElevenLabs Infinite TTS API - Anime Lektor PL { run: \"auto\" }\n",
        "import os\n",
        "import shutil\n",
        "import glob\n",
        "import asyncio\n",
        "import nest_asyncio\n",
        "import aiohttp\n",
        "import pysrt\n",
        "import zipfile\n",
        "from pydub import AudioSegment\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import display, HTML\n",
        "from google.colab import files\n",
        "from elevenlabs import set_api_key, voices\n",
        "\n",
        "#===============================================================================\n",
        "# Button CSS\n",
        "display(HTML('''\n",
        "<style>\n",
        "    .widget-button {\n",
        "        font-weight: bold !important;\n",
        "    }\n",
        "    .widget-button.jupyter-widgets.widget-button.mod-active,\n",
        "    .widget-button:active {\n",
        "        background-color: #2d2e2e;\n",
        "    }\n",
        "    .widget-toggle-button {\n",
        "        font-weight: bold !important;\n",
        "    }\n",
        "    .widget-toggle-button.jupyter-widgets.widget-toggle-button.mod-active,\n",
        "    .widget-toggle-button:active {\n",
        "        background-color: #2d2e2e;\n",
        "    }\n",
        "</style>\n",
        "'''))\n",
        "#===============================================================================\n",
        "\n",
        "os.chdir('/content/')\n",
        "os.chdir('/content/drive/Shareddrives/Dysk_0/11Labs_TTS_Colab/')\n",
        "nest_asyncio.apply()\n",
        "\n",
        "class AudioGenerator:\n",
        "    def __init__(self, input_folder='input', output_folder='audio_output'):\n",
        "        self.api_keys = []\n",
        "        self.api_key_statuses = {key['key']: True for key in self.api_keys}\n",
        "        self.voice_ids = {key['key']: None for key in self.api_keys}\n",
        "        self.premade_voice_id = None\n",
        "\n",
        "        self.auto_download = False\n",
        "\n",
        "        self.audio_cache = {}\n",
        "        self.use_cache = False\n",
        "\n",
        "        self.input_folder = input_folder\n",
        "        self.output_folder = output_folder\n",
        "\n",
        "        os.makedirs(input_folder, exist_ok=True)\n",
        "        os.makedirs(output_folder, exist_ok=True)\n",
        "\n",
        "        self.voice_names = {\n",
        "            'Bella - Normalna Kobieta': ['Bella'],\n",
        "            'Brian - Powolny Narrator Dokumentalny': ['Brian', 'Brian - Slow speaking and deep'],\n",
        "            'Knightley - Głęboki Narrator Książkowy': ['Knightley', 'Knightley - dapper and deep narrator'],\n",
        "            'Joanne - Pozytywna Introspekcyjna Kobieta': ['Joanne', 'Joanne - pensive, introspective'],\n",
        "            'Scarlett - Uwodzicielska Niestabilna Kobieta': ['Scarlett', 'Scarlett - 💯% seductive 🔥'],\n",
        "            'Nicole - Szepcząca Kobieta': ['Nicole'],\n",
        "            'Wanda - Spokojna Kobieta': ['Wanda', 'Wanda - calm female'],\n",
        "            'Hallie - Miękko Mówiąca Subtelna Kobieta': ['Hallie', 'Hallie - soft-spoken and subtle'],\n",
        "        }\n",
        "\n",
        "        self.voice_dropdown = widgets.Dropdown(options=list(self.voice_names.keys()))\n",
        "        display(self.voice_dropdown)\n",
        "\n",
        "    def update_api_keys(self, api_keys):\n",
        "        self.api_keys = api_keys\n",
        "        self.api_key_statuses = {key['key']: True for key in api_keys}\n",
        "        self.voice_ids = {key['key']: None for key in api_keys}\n",
        "\n",
        "    def create_headers(self, api_key):\n",
        "        return {\n",
        "            \"Accept\": \"audio/mpeg\",\n",
        "            \"Content-Type\": \"application/json\",\n",
        "            \"xi-api-key\": api_key\n",
        "        }\n",
        "\n",
        "    def create_data(self, text):\n",
        "        return {\n",
        "            \"text\": text,\n",
        "            \"model_id\": \"eleven_multilingual_v2\",\n",
        "            \"voice_settings\": {\n",
        "                \"stability\": 1,\n",
        "                \"similarity_boost\": 0.75\n",
        "            }\n",
        "        }\n",
        "\n",
        "    def find_voice_id(self, voices, voice_names):\n",
        "        for voice in voices.voices:\n",
        "            if voice.name in voice_names:\n",
        "                if voice.category == 'premade':\n",
        "                    self.premade_voice_id = voice.voice_id\n",
        "                return voice.voice_id\n",
        "        return None\n",
        "\n",
        "    async def generate_audio_url(self, api_key):\n",
        "        set_api_key(api_key)\n",
        "        if self.premade_voice_id is not None:\n",
        "            return f\"https://api.elevenlabs.io/v1/text-to-speech/{self.premade_voice_id}\"\n",
        "        elif self.voice_ids[api_key] is None:\n",
        "            voice_list = voices()\n",
        "            self.voice_ids[api_key] = self.find_voice_id(voice_list, self.voice_names[self.voice_dropdown.value])\n",
        "        if self.voice_ids[api_key]:\n",
        "            return f\"https://api.elevenlabs.io/v1/text-to-speech/{self.voice_ids[api_key]}\"\n",
        "        else:\n",
        "            return None\n",
        "\n",
        "    async def write_audio_file(self, response, audio_file_path, CHUNK_SIZE):\n",
        "        with open(audio_file_path, 'wb') as f:\n",
        "            while True:\n",
        "                chunk = await response.content.read(CHUNK_SIZE)\n",
        "                if not chunk:\n",
        "                    break\n",
        "                f.write(chunk)\n",
        "\n",
        "    async def generate_audio(self, text, index, api_key, temp_folder):\n",
        "        CHUNK_SIZE = 1024\n",
        "        url = await self.generate_audio_url(api_key)\n",
        "        if url is None:\n",
        "            print(f\"Klucz API {api_key} nie ma dostępu do wybranego głosu.\")\n",
        "            self.api_key_statuses[api_key] = False\n",
        "            return None, False\n",
        "        headers = self.create_headers(api_key)\n",
        "        data = self.create_data(text)\n",
        "\n",
        "        audio_file_path = f'{temp_folder}/{index}.mp3'\n",
        "\n",
        "        if self.use_cache and text in self.audio_cache:\n",
        "            return self.audio_cache[text], True\n",
        "\n",
        "        async with aiohttp.ClientSession() as session:\n",
        "            async with session.post(url, json=data, headers=headers) as response:\n",
        "                if response.status == 200:\n",
        "                    await self.write_audio_file(response, audio_file_path, CHUNK_SIZE)\n",
        "                    self.audio_cache[text] = audio_file_path\n",
        "                    return audio_file_path, False\n",
        "                else:\n",
        "                    self.api_key_statuses[api_key] = False\n",
        "                    return None, False\n",
        "\n",
        "    def copy_audio_file(self, audio_file_path, temp_folder, index):\n",
        "        new_audio_file_path = f'{temp_folder}/{index}.mp3'\n",
        "        if audio_file_path != new_audio_file_path:\n",
        "            shutil.copy(audio_file_path, new_audio_file_path)\n",
        "        return new_audio_file_path\n",
        "\n",
        "    def print_subtitle_info(self, index, text, char_count, from_cache):\n",
        "        print(f\"{index}. {text} RC: {char_count if not from_cache else 0}\")\n",
        "\n",
        "    def load_srt_file(self, filename):\n",
        "        return pysrt.open(filename, encoding='utf-8')\n",
        "\n",
        "    # def convert_audio_files(self, subs, temp_folder):\n",
        "    #     for index, _ in enumerate(subs, start=1):\n",
        "    #         audio_file = f'{temp_folder}/{index}.mp3'\n",
        "    #         audio = AudioSegment.from_mp3(audio_file)\n",
        "    #         audio.export(audio_file.replace('.mp3', '.wav'), format='wav')\n",
        "\n",
        "    def convert_audio_files(self, subs, temp_folder):\n",
        "        for sub in subs:\n",
        "            audio_file = f'{temp_folder}/{sub.index}.mp3'\n",
        "            if os.path.exists(audio_file):\n",
        "                audio = AudioSegment.from_mp3(audio_file)\n",
        "                audio.export(audio_file.replace('.mp3', '.wav'), format='wav')\n",
        "            else:\n",
        "                print(f\"Plik {audio_file} nie istnieje, pomijam.\")\n",
        "\n",
        "    # def combine_audio(self, subs, filename, temp_folder):\n",
        "    #     combined = AudioSegment.silent(duration=0)\n",
        "\n",
        "    #     for index, sub in enumerate(subs, start=1):\n",
        "    #         start_time = sub.start.ordinal\n",
        "    #         silence = AudioSegment.silent(duration=start_time - len(combined))\n",
        "    #         combined += silence\n",
        "\n",
        "    #         audio_file = f'{temp_folder}/{index}.wav'\n",
        "    #         audio = AudioSegment.from_wav(audio_file)\n",
        "\n",
        "    #         combined += audio\n",
        "\n",
        "    #     output_filename = os.path.basename(filename).replace('.srt', '.eac3')\n",
        "    #     combined.export(\n",
        "    #         f\"{self.output_folder}/{output_filename}\", format='wav')\n",
        "    #     os.system(\n",
        "    #         f\"ffmpeg -i {self.output_folder}/{output_filename} -c:a {self.output_folder}/{output_filename}\")\n",
        "    def combine_audio(self, subs, filename, temp_folder):\n",
        "        combined = AudioSegment.silent(duration=0)\n",
        "\n",
        "        for sub in subs:\n",
        "            start_time = sub.start.ordinal\n",
        "            silence = AudioSegment.silent(duration=start_time - len(combined))\n",
        "            combined += silence\n",
        "\n",
        "            audio_file = f'{temp_folder}/{sub.index}.wav'\n",
        "            if os.path.exists(audio_file):\n",
        "                audio = AudioSegment.from_wav(audio_file)\n",
        "                combined += audio\n",
        "            else:\n",
        "                print(f\"Plik {audio_file} nie istnieje, pomijam.\")\n",
        "\n",
        "        output_filename = os.path.basename(filename).replace('.srt', '.eac3')\n",
        "        combined.export(\n",
        "            f\"{self.output_folder}/{output_filename}\", format='wav')\n",
        "        os.system(\n",
        "            f\"ffmpeg -i {self.output_folder}/{output_filename} -c:a {self.output_folder}/{output_filename}\")\n",
        "\n",
        "    async def process_file(self, filename):\n",
        "        print(f\"Przetwarzanie pliku: {filename}\")\n",
        "        base_filename = os.path.basename(filename)\n",
        "        temp_folder = self.create_temp_folder(base_filename)\n",
        "\n",
        "        subs = self.load_srt_file(filename)\n",
        "        await self.process_subtitles(subs, temp_folder)\n",
        "        self.convert_audio_files(subs, temp_folder)\n",
        "        self.combine_audio(subs, filename, temp_folder)\n",
        "        print(f\"Przetworzono plik: {filename}\")\n",
        "\n",
        "    # def create_temp_folder(self, base_filename):\n",
        "    #     temp_folder = f'tmp_output_{base_filename}'\n",
        "    #     os.makedirs(temp_folder, exist_ok=True)\n",
        "    #     return temp_folder\n",
        "    def create_temp_folder(self, base_filename):\n",
        "        base_filename_without_ext = os.path.splitext(base_filename)[0]\n",
        "        temp_folder = f'tmp_output_{base_filename_without_ext}'\n",
        "        os.makedirs(temp_folder, exist_ok=True)\n",
        "        return temp_folder\n",
        "\n",
        "    # async def process_subtitles(self, subs, temp_folder):\n",
        "    #     total_char_count = 0\n",
        "    #     for index, sub in enumerate(subs, start=1):\n",
        "    #         char_count = len(sub.text)\n",
        "    #         for api_key_dict in self.api_keys:\n",
        "    #             api_key = api_key_dict['key']\n",
        "    #             if self.api_key_statuses[api_key]:\n",
        "    #                 audio_file_path, from_cache = await self.generate_audio(sub.text, index, api_key, temp_folder)\n",
        "    #                 if audio_file_path:\n",
        "    #                     new_audio_file_path = self.copy_audio_file(audio_file_path, temp_folder, index)\n",
        "    #                     self.print_subtitle_info(index, sub.text, char_count, from_cache)\n",
        "    #                     total_char_count += char_count if not from_cache else 0\n",
        "    #                     break\n",
        "    #         else:\n",
        "    #             print(\"Wszystkie klucze API są wyczerpane. Proszę dodać więcej kluczy.\")\n",
        "    #     print(f\"Łączna liczba znaków: {total_char_count}\")\n",
        "    async def process_subtitles(self, subs, temp_folder):\n",
        "        total_char_count = 0\n",
        "        for sub in subs:\n",
        "            char_count = len(sub.text)\n",
        "            audio_file_path = f'{temp_folder}/{sub.index}.mp3'\n",
        "            if os.path.exists(audio_file_path):\n",
        "                print(f\"Plik {audio_file_path} już istnieje, pomijam.\")\n",
        "                continue\n",
        "            for api_key_dict in self.api_keys:\n",
        "                api_key = api_key_dict['key']\n",
        "                if self.api_key_statuses[api_key]:\n",
        "                    audio_file_path, from_cache = await self.generate_audio(sub.text, sub.index, api_key, temp_folder)\n",
        "                    if audio_file_path:\n",
        "                        new_audio_file_path = self.copy_audio_file(audio_file_path, temp_folder, sub.index)\n",
        "                        self.print_subtitle_info(sub.index, sub.text, char_count, from_cache)\n",
        "                        total_char_count += char_count if not from_cache else 0\n",
        "                        break\n",
        "            else:\n",
        "                print(\"Wszystkie klucze API są wyczerpane. Proszę dodać więcej kluczy.\")\n",
        "        print(f\"Łączna liczba znaków: {total_char_count}\")\n",
        "\n",
        "    async def process_all_files(self):\n",
        "        files = glob.glob(f'{self.input_folder}/*.srt')\n",
        "        files.sort()\n",
        "        for filename in files:\n",
        "            await self.process_file(filename)\n",
        "\n",
        "    def start_processing(self):\n",
        "        upload_button = self.create_upload_button()\n",
        "        display(upload_button)\n",
        "\n",
        "        cache_button = self.create_cache_button()\n",
        "        display(cache_button)\n",
        "\n",
        "        auto_download_button = self.create_auto_download_button()\n",
        "        display(auto_download_button)\n",
        "\n",
        "        start_button = self.create_start_button()\n",
        "        display(start_button)\n",
        "\n",
        "    def upload_srt_files(self, b=None):\n",
        "        try:\n",
        "            uploaded = files.upload()\n",
        "\n",
        "            for fn in uploaded.keys():\n",
        "                print('User uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "                    name=fn, length=len(uploaded[fn])))\n",
        "\n",
        "            for fn in uploaded.keys():\n",
        "                shutil.move(fn, f'{self.input_folder}/{fn}')\n",
        "        except:\n",
        "            pass\n",
        "\n",
        "    def create_upload_button(self):\n",
        "        upload_button = widgets.Button(\n",
        "            description='Prześlij Pliki .SRT',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        upload_button.on_click(self.upload_srt_files)\n",
        "        return upload_button\n",
        "\n",
        "    def create_cache_button(self):\n",
        "        cache_button = widgets.ToggleButton(\n",
        "            value=self.use_cache,\n",
        "            description='Użyj Cache - Zaoszczędź RC',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        cache_button.observe(self.update_cache_status, names='value')\n",
        "        return cache_button\n",
        "\n",
        "    def update_cache_status(self, change):\n",
        "        self.use_cache = change['new']\n",
        "\n",
        "    def create_auto_download_button(self):\n",
        "        auto_download_button = widgets.ToggleButton(\n",
        "            value=False,\n",
        "            description='Automatyczne Pobieranie',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        auto_download_button.observe(self.update_auto_download_status, names='value')\n",
        "        return auto_download_button\n",
        "\n",
        "    def update_auto_download_status(self, change):\n",
        "        self.auto_download = change['new']\n",
        "\n",
        "    def create_download_button(self):\n",
        "        download_button = widgets.Button(\n",
        "            description='Pobierz Pliki',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        download_button.on_click(self.download_files)\n",
        "        return download_button\n",
        "\n",
        "    def download_files(self, b=None):\n",
        "        zip_filename = 'audio_files.zip'\n",
        "        with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
        "            for filename in glob.glob(f'{self.output_folder}/*.eac3'):\n",
        "                zipf.write(filename)\n",
        "        files.download(zip_filename)\n",
        "\n",
        "\n",
        "    def create_start_button(self):\n",
        "        start_button = widgets.Button(\n",
        "            description='Wygeneruj Audio',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        start_button.on_click(self.start_processing_callback)\n",
        "        return start_button\n",
        "\n",
        "    @execution_timer\n",
        "    def start_processing_callback(self, b):\n",
        "        loop = asyncio.get_event_loop()\n",
        "        loop.run_until_complete(self.process_all_files())\n",
        "        if self.auto_download:\n",
        "            self.download_files()\n",
        "        download_button = self.create_download_button()\n",
        "        display(download_button)\n",
        "\n",
        "def main():\n",
        "    display(HTML('<h1>ElevenLabs Infinite TTS API - Anime Lektor PL</h1>'))\n",
        "    audio_generator = AudioGenerator()\n",
        "    audio_generator.update_api_keys(api_keys)\n",
        "    audio_generator.start_processing()\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JeO0N1smEhN-"
      },
      "outputs": [],
      "source": [
        "<break time=\"1.5s\" />"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AmgP429xEOV9"
      },
      "source": [
        "# INNE PRZYDATNE ❌"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BG2fu7anM5kx"
      },
      "source": [
        "## Przykład z Biblioteką Pythona Elevenlabs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wMj3VNJD5qqA"
      },
      "outputs": [],
      "source": [
        "# from elevenlabs import voices, generate\n",
        "# from elevenlabs import generate, play, set_api_key\n",
        "# import rich\n",
        "\n",
        "# audio = generate(\n",
        "#     text=\"Witaj świecie, jak się masz?\",\n",
        "#     api_key=\"69629e2241ca3f96a3e97587ad5072e5\",\n",
        "#     voice=\"Scarlett - 💯% seductive 🔥\",\n",
        "#     model='eleven_multilingual_v2'\n",
        "# )\n",
        "# # play(audio)\n",
        "# play(audio, notebook=True)  # notebook=True - odtwarzanie w google colab\n",
        "\n",
        "# f = open(\"output.mp3\", \"wb\")\n",
        "# f.write(audio)\n",
        "# f.close()\n",
        "\n",
        "\n",
        "import requests\n",
        "\n",
        "CHUNK_SIZE = 1024\n",
        "url = \"https://api.elevenlabs.io/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL\"\n",
        "\n",
        "headers = {\n",
        "  \"Accept\": \"audio/mpeg\",\n",
        "  \"Content-Type\": \"application/json\",\n",
        "  \"xi-api-key\": \"4d88c7168ddf8a163ffbf176276e72c5\"\n",
        "}\n",
        "\n",
        "data = {\n",
        "  \"text\": \"Witaj świecie, jak się masz?\",\n",
        "  \"model_id\": \"eleven_multilingual_v2\",\n",
        "  \"voice_settings\": {\n",
        "    \"stability\": 0.5,\n",
        "    \"similarity_boost\": 0.75\n",
        "  }\n",
        "}\n",
        "\n",
        "response = requests.post(url, json=data, headers=headers)\n",
        "with open('output.mp3', 'wb') as f:\n",
        "    for chunk in response.iter_content(chunk_size=CHUNK_SIZE):\n",
        "        if chunk:\n",
        "            f.write(chunk)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rXlgAmbNM5kx"
      },
      "source": [
        "## Lisa Głosów i Ich Ustawień / Wyszukiwanie głosów po ich nazwach\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iqCphFrZM5kx"
      },
      "outputs": [],
      "source": [
        "# pip install elevenlabs\n",
        "# pip install rich\n",
        "from elevenlabs import voices\n",
        "from elevenlabs import set_api_key\n",
        "import rich\n",
        "\n",
        "# Lisa głosów i ich ustawień\n",
        "\n",
        "# set_api_key(\"69629e2241ca3f96a3e97587ad5072e5\")\n",
        "# set_api_key(\"96028d102d0734fd815519ead6c6a625\")\n",
        "set_api_key(\"77c2a2122bbfeb8e570f91ef3cb27982\")\n",
        "\n",
        "voices = voices()\n",
        "rich.print(voices)\n",
        "\n",
        "\n",
        "# import requests\n",
        "\n",
        "# url = \"https://api.elevenlabs.io/v1/voices/\"\n",
        "\n",
        "# headers = {\n",
        "#     \"Accept\": \"application/json\",\n",
        "#     \"xi-api-key\": \"69629e2241ca3f96a3e97587ad5072e5\"\n",
        "# }\n",
        "\n",
        "# response = requests.get(url, headers=headers)\n",
        "\n",
        "# rich.print(response.text)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7xsDD2qccps8"
      },
      "outputs": [],
      "source": [
        "## Wyszukiwanie id głosu po jego nazwach\n",
        "from elevenlabs import voices\n",
        "from elevenlabs import set_api_key\n",
        "import rich\n",
        "\n",
        "def find_voice_id(voices, voice_names):\n",
        "    for voice in voices.voices:\n",
        "        if voice.name in voice_names:\n",
        "            return voice.voice_id\n",
        "    return None\n",
        "\n",
        "# Ustaw klucz API\n",
        "set_api_key(\"77c2a2122bbfeb8e570f91ef3cb27982\") # Brian - Slow speaking and deep\n",
        "# set_api_key(\"33c6333781381542275a0fef3c844028\") # Brian\n",
        "# Pobierz listę głosów\n",
        "voices = voices()\n",
        "\n",
        "# Wyszukaj identyfikator głosu\n",
        "voice_id = find_voice_id(voices, ['Brian', 'Brian - Slow speaking and deep'])\n",
        "\n",
        "# Jeśli identyfikator głosu został znaleziony, użyj go do generowania dźwięku\n",
        "if voice_id:\n",
        "    url = f\"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}\"\n",
        "    # Tutaj możesz użyć url do generowania dźwięku\n",
        "    print(url)\n",
        "else:\n",
        "    print(\"Nie znaleziono głosu.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HQM9i5Zb-lIK"
      },
      "outputs": [],
      "source": [
        "import asyncio\n",
        "import aiohttp\n",
        "from elevenlabs import voices as voices_func, set_api_key\n",
        "\n",
        "async def find_voice_id(session, api_key, voice_names):\n",
        "    # Ustaw klucz API\n",
        "    set_api_key(api_key)\n",
        "\n",
        "    # Pobierz listę głosów\n",
        "    voices = voices_func()\n",
        "\n",
        "    for voice in voices.voices:\n",
        "        if voice.name in voice_names:\n",
        "            return voice.voice_id\n",
        "\n",
        "    return None\n",
        "\n",
        "async def main():\n",
        "    api_keys = [\"77c2a2122bbfeb8e570f91ef3cb27982\",\n",
        "                \"33c6333781381542275a0fef3c844028\",\n",
        "                \"bf4e905fec0e3c7d7aa8710fa4493148\",\n",
        "                \"d6ccf77426a0adf7b29612366f9cbd18\",\n",
        "                \"59f3ff34e070b562f8ac4f5847bf5f77\",\n",
        "                \"4d88c7168ddf8a163ffbf176276e72c5\",\n",
        "                \"96028d102d0734fd815519ead6c6a625\",\n",
        "                \"69629e2241ca3f96a3e97587ad5072e5\",\"77c2a2122bbfeb8e570f91ef3cb27982\",\n",
        "                \"33c6333781381542275a0fef3c844028\",\n",
        "                \"bf4e905fec0e3c7d7aa8710fa4493148\",\n",
        "                \"d6ccf77426a0adf7b29612366f9cbd18\",\n",
        "                \"59f3ff34e070b562f8ac4f5847bf5f77\",\n",
        "                \"4d88c7168ddf8a163ffbf176276e72c5\",\n",
        "                \"96028d102d0734fd815519ead6c6a625\",\n",
        "                \"69629e2241ca3f96a3e97587ad5072e5\"\n",
        "                ]\n",
        "    voice_names = ['Brian', 'Brian - Slow speaking and deep']\n",
        "\n",
        "    async with aiohttp.ClientSession() as session:\n",
        "        tasks = [find_voice_id(session, api_key, voice_names) for api_key in api_keys]\n",
        "        voice_ids = await asyncio.gather(*tasks)\n",
        "\n",
        "        for api_key, voice_id in zip(api_keys, voice_ids):\n",
        "            if voice_id:\n",
        "                url = f\"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}\"\n",
        "                print(f\"API Key: {api_key}, URL: {url}\")\n",
        "            else:\n",
        "                print(f\"API Key: {api_key}, Nie znaleziono głosu.\")\n",
        "\n",
        "# Uruchom główną funkcję asynchroniczną\n",
        "await main()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7pgKEYz5ATGp"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aqkvCKDTECt8"
      },
      "source": [
        "## Przykładowe requests z API"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "HBmDLqM0TmjM"
      },
      "outputs": [],
      "source": [
        "#@title Przykładowe requests z API\n",
        "\n",
        "import requests\n",
        "import rich\n",
        "\n",
        "headers = {\n",
        "    \"Accept\": \"application/json\",\n",
        "    \"xi-api-key\": \"69629e2241ca3f96a3e97587ad5072e5\"\n",
        "}\n",
        "\n",
        "# Informacjie o wszystkich głosach\n",
        "# Voices(\n",
        "#     voices=[\n",
        "#         Voice(\n",
        "#             voice_id='21m00Tcm4TlvDq8ikWAM',\n",
        "#             name='Rachel',\n",
        "#             category='premade',\n",
        "#             description=None,\n",
        "#             labels={\n",
        "#                 'accent': 'american',\n",
        "#                 'description': 'calm',\n",
        "#                 'age': 'young',\n",
        "#                 'gender': 'female',\n",
        "#                 'use case': 'narration'\n",
        "#             },\n",
        "#             samples=None,\n",
        "#             settings=VoiceSettings(stability=0.5, similarity_boost=0.75),\n",
        "#             design=None,\n",
        "#             preview_url='https://storage.googleapis.com/eleven-public-prod/premade/voices/21m00Tcm4TlvDq8ikWAM/df67\n",
        "# 88f9-5c96-470d-8312-aab3b3d8f50a.mp3'\n",
        "#         ),\n",
        "\n",
        "url = \"https://api.elevenlabs.io/v1/voices/\"\n",
        "response = requests.get(url, headers=headers)\n",
        "\n",
        "rich.print(response.text)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# Ustawienia domyśle głosu\n",
        "\n",
        "# {\"stability\":0.5,\"similarity_boost\":0.5,\"style\":0.0,\"use_speaker_boost\":true}\n",
        "\n",
        "url = \"https://api.elevenlabs.io/v1/voices/{voice_id}/settings\"\n",
        "response = requests.get(url, headers=headers)\n",
        "\n",
        "print(response.text)\n",
        "\n",
        "\n",
        "# Ustawienia konta\n",
        "\n",
        "# {\"stability\":0.5,\"similarity_boost\":0.5,\"style\":0.0,\"use_speaker_boost\":true}\n",
        "# {\"subscription\":{\"tier\":\"free\",\"character_count\":10000,\"character_limit\":10000,\"can_extend_character_limit\":false,\"\n",
        "# allowed_to_extend_character_limit\":false,\"next_character_count_reset_unix\":1693860788,\"voice_limit\":3,\"max_voice_ad\n",
        "# d_edits\":54,\"voice_add_edit_counter\":1,\"professional_voice_limit\":0,\"can_extend_voice_limit\":false,\"can_use_instant\n",
        "# _voice_cloning\":false,\"can_use_professional_voice_cloning\":false,\"currency\":null,\"status\":\"free\"},\"is_new_user\":tru\n",
        "# e,\"xi_api_key\":\"69629e2241ca3f96a3e97587ad5072e5\",\"can_use_delayed_payment_methods\":false}\n",
        "\n",
        "\n",
        "url = \"https://api.elevenlabs.io/v1/user\"\n",
        "response = requests.get(url, headers=headers)\n",
        "\n",
        "rich.print(response.text)\n",
        "\n",
        "\n",
        "# Lista modeli i informacjie o nich\n",
        "\n",
        "# [{\"model_id\":\"eleven_multilingual_v2\",\"name\":\"Eleven Multilingual\n",
        "# v2\",\"can_be_finetuned\":true,\"can_do_text_to_speech\":true,\"can_do_voice_conversion\":true,\"can_use_style\":true,\"can_u\n",
        "# se_speaker_boost\":true,\"serves_pro_voices\":false,\"token_cost_factor\":1.0,\"description\":\"Our state of the art\n",
        "# multilingual speech synthesis model, able to generate life-like speech in 28\n",
        "# languages.\",\"requires_alpha_access\":false,\"max_characters_request_free_user\":2500,\"max_characters_request_subscribe\n",
        "# d_user\":5000,\"languages\":[{\"language_id\":\"en\",\"name\":\"English\"},{\"language_id\":\"ja\",\"name\":\"Japanese\"},{\"language_i\n",
        "# d\":\"zh\",\"name\":\"Chinese\"},{\"language_id\":\"de\",\"name\":\"German\"},{\"language_id\":\"hi\",\"name\":\"Hindi\"},{\"language_id\":\"\n",
        "# fr\",\"name\":\"French\"},{\"language_id\":\"ko\",\"name\":\"Korean\"},{\"language_id\":\"pt\",\"name\":\"Portuguese\"},{\"language_id\":\"\n",
        "# it\",\"name\":\"Italian\"},{\"language_id\":\"es\",\"name\":\"Spanish\"},{\"language_id\":\"id\",\"name\":\"Indonesian\"},{\"language_id\"\n",
        "# :\"nl\",\"name\":\"Dutch\"},{\"language_id\":\"tr\",\"name\":\"Turkish\"},{\"language_id\":\"fil\",\"name\":\"Filipino\"},{\"language_id\":\n",
        "# \"pl\",\"name\":\"Polish\"},{\"language_id\":\"sv\",\"name\":\"Swedish\"},{\"language_id\":\"bg\",\"name\":\"Bulgarian\"},{\"language_id\":\n",
        "# \"ro\",\"name\":\"Romanian\"},{\"language_id\":\"ar\",\"name\":\"Arabic\"},{\"language_id\":\"cs\",\"name\":\"Czech\"},{\"language_id\":\"el\n",
        "# \",\"name\":\"Greek\"},{\"language_id\":\"fi\",\"name\":\"Finnish\"},{\"language_id\":\"hr\",\"name\":\"Croatian\"},{\"language_id\":\"ms\",\n",
        "# \"name\":\"Malay\"},{\"language_id\":\"sk\",\"name\":\"Slovak\"},{\"language_id\":\"da\",\"name\":\"Danish\"},{\"language_id\":\"ta\",\"name\n",
        "# \":\"Tamil\"},{\"language_id\":\"uk\",\"name\":\"Ukrainian\"}]},\n",
        "\n",
        "url = \"https://api.elevenlabs.io/v1/models\"\n",
        "response = requests.get(url, headers=headers)\n",
        "rich.print(response.text)\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_3XchGpZM5kz"
      },
      "source": [
        "## Text to Speech"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YaXwciiB_Q5i"
      },
      "outputs": [],
      "source": [
        "import ipywidgets as widgets\n",
        "from google.colab import files\n",
        "import IPython.display as ipd\n",
        "import requests\n",
        "import os\n",
        "from IPython.display import display, HTML\n",
        "\n",
        "# Ustawienia generowania dźwięku\n",
        "CHUNK_SIZE = 2048\n",
        "url = \"https://api.elevenlabs.io/v1/text-to-speech/ZFeKTJIJXSBdBdyngreH\"\n",
        "\n",
        "headers = {\n",
        "    \"Accept\": \"audio/mpeg\",\n",
        "    \"Content-Type\": \"application/json\",\n",
        "    \"xi-api-key\": \"69629e2241ca3f96a3e97587ad5072e5\"\n",
        "}\n",
        "\n",
        "# Interaktywne widgety do konfiguracji generowania dźwięku\n",
        "text_widget = widgets.Textarea(\n",
        "    value=\"OK\",  # Domyślny tekst\n",
        "    description=\"Tekst:\",\n",
        "    rows=5,\n",
        "    layout=widgets.Layout(width=\"90%\", height=\"150px\"),\n",
        "    max_chars=5000\n",
        ")\n",
        "\n",
        "model_id_widget = widgets.Dropdown(\n",
        "    options=[\"eleven_monolingual_v1\", \"eleven_multilingual_v1\", \"eleven_multilingual_v2\"],\n",
        "    value=\"eleven_multilingual_v2\",\n",
        "    description=\"ID modelu:\"\n",
        ")\n",
        "\n",
        "stability_widget = widgets.FloatSlider(\n",
        "    value=0.5,\n",
        "    min=0.1,\n",
        "    max=1.0,\n",
        "    step=0.1,\n",
        "    description=\"Stabilność:\"\n",
        ")\n",
        "\n",
        "similarity_boost_widget = widgets.FloatSlider(\n",
        "    value=0.5,\n",
        "    min=0.1,\n",
        "    max=1.0,\n",
        "    step=0.1,\n",
        "    description=\"Podobność:\"\n",
        ")\n",
        "\n",
        "# Funkcja do pobierania pliku audio\n",
        "def download_audio(b):\n",
        "    data = {\n",
        "        \"text\": text_widget.value,\n",
        "        \"model_id\": model_id_widget.value,\n",
        "        \"voice_settings\": {\n",
        "            \"stability\": stability_widget.value,\n",
        "            \"similarity_boost\": similarity_boost_widget.value\n",
        "        }\n",
        "    }\n",
        "\n",
        "    response = requests.post(url, json=data, headers=headers)\n",
        "\n",
        "    counter = 1\n",
        "    output_dir = 'output_audio'\n",
        "    os.makedirs(output_dir, exist_ok=True)\n",
        "    output_filename = create_unique_filename(output_dir, counter)\n",
        "\n",
        "    with open(output_filename, 'wb') as f:\n",
        "        for chunk in response.iter_content(chunk_size=CHUNK_SIZE):\n",
        "            if chunk:\n",
        "                f.write(chunk)\n",
        "\n",
        "    with output_audio_widget:\n",
        "        display(HTML(f'<h3>Plik: {os.path.basename(output_filename)}</h3>'))  # Formatowanie jako nagłówek H3\n",
        "        audio_display = ipd.Audio(output_filename)\n",
        "        display(audio_display)\n",
        "\n",
        "# Przycisk do pobierania pliku\n",
        "button = widgets.Button(description=\"Wygeneruj Audio\",\n",
        "                        layout=widgets.Layout(width=\"300px\", height=\"30px\"))\n",
        "\n",
        "output_audio_widget = widgets.Output()\n",
        "output = widgets.Output()\n",
        "button.on_click(download_audio)\n",
        "\n",
        "# Wyświetlanie opisu, listy audio, podglądu i przycisków pobierania\n",
        "display(\n",
        "    HTML('<h1>ElevenLabs API Google Colab</h1>'),\n",
        "    text_widget,\n",
        "    model_id_widget,\n",
        "    stability_widget,\n",
        "    similarity_boost_widget,\n",
        "    button,\n",
        "    output_audio_widget,\n",
        "    output\n",
        ")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oQJVtDCuM5ky"
      },
      "source": [
        "## Wyświetl Ustawienia Domyślne Danego Głosu"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JQMAlFVk9QnB"
      },
      "outputs": [],
      "source": [
        "import requests\n",
        "import rich\n",
        "url = \"https://api.elevenlabs.io/v1/voices/ZFeKTJIJXSBdBdyngreH/settings\"\n",
        "\n",
        "headers = {\n",
        "    \"Accept\": \"application/json\",\n",
        "    \"xi-api-key\": \"69629e2241ca3f96a3e97587ad5072e5\"\n",
        "}\n",
        "\n",
        "response = requests.get(url, headers=headers)\n",
        "\n",
        "print(response.text)\n",
        "\n",
        "\n",
        "import requests\n",
        "\n",
        "url = \"https://api.elevenlabs.io/v1/user\"\n",
        "\n",
        "headers = {\n",
        "    \"Accept\": \"application/json\",\n",
        "    \"xi-api-key\": \"69629e2241ca3f96a3e97587ad5072e5\"\n",
        "}\n",
        "\n",
        "response = requests.get(url, headers=headers)\n",
        "\n",
        "rich.print(response.text)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FGP5SNBFeHVm"
      },
      "source": [
        "## Pobieranie Audio"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FsGm0v1_XUF9"
      },
      "outputs": [],
      "source": [
        "import ipywidgets as widgets\n",
        "from google.colab import files\n",
        "import IPython.display as ipd\n",
        "import requests\n",
        "import os\n",
        "import zipfile\n",
        "from IPython.display import display, HTML\n",
        "\n",
        "# Filtruj i sortuj pliki audio alfabetycznie\n",
        "audio_files = sorted([filename for filename in os.listdir(output_dir) if filename.endswith('.mp3')])\n",
        "\n",
        "# Wybór wielu plików audio\n",
        "selected_audio = widgets.SelectMultiple(\n",
        "    options=audio_files,\n",
        "    description='',\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "# Opis wyboru audio\n",
        "audio_selection_description = widgets.HTML('<h3>Zaznacz Audio Do Pobrania - (Ctrl / Shift + Click)</h3>')\n",
        "\n",
        "# Widget do wyświetlania nazwy pliku i podglądu wybranych plików audio\n",
        "output_audio_widget = widgets.Output()\n",
        "\n",
        "# Funkcja do wyświetlania nazwy pliku i podglądu audio\n",
        "def display_selected_audio(change):\n",
        "    with output_audio_widget:\n",
        "        output_audio_widget.clear_output()\n",
        "        selected_files = selected_audio.value\n",
        "        for filename in selected_files:\n",
        "            audio_path = os.path.join(output_dir, filename)\n",
        "            display(HTML(f'<h3>File: {filename}</h3>'))  # Formatowanie jako nagłówek H3\n",
        "            audio_display = ipd.Audio(audio_path)\n",
        "            display(audio_display)\n",
        "\n",
        "selected_audio.observe(display_selected_audio, names='value')\n",
        "\n",
        "download_selected_button = widgets.Button(description='Pobierz Zaznaczone',\n",
        "                                          layout=widgets.Layout(width='300px', height='30px'))\n",
        "\n",
        "download_all_button = widgets.Button(description='Pobierz Wszystko',\n",
        "                                     layout=widgets.Layout(width='300px', height='30px'))\n",
        "\n",
        "# Funkcja do pobierania zaznaczonych plików audio\n",
        "def download_selected_audio(b):\n",
        "    selected_files = selected_audio.value\n",
        "    zip_filename = os.path.join(output_dir, 'selected_audio.zip')\n",
        "    with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
        "        for filename in selected_files:\n",
        "            audio_path = os.path.join(output_dir, filename)\n",
        "            zipf.write(audio_path, os.path.basename(audio_path))\n",
        "    files.download(zip_filename)\n",
        "\n",
        "# Funkcja do pobierania wszystkich plików audio\n",
        "def download_all_audio(b):\n",
        "    zip_filename = os.path.join(output_dir, 'all_audio.zip')\n",
        "    with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
        "        for filename in audio_files:\n",
        "            audio_path = os.path.join(output_dir, filename)\n",
        "            zipf.write(audio_path, os.path.basename(audio_path))\n",
        "    files.download(zip_filename)\n",
        "\n",
        "download_selected_button.on_click(download_selected_audio)\n",
        "download_all_button.on_click(download_all_audio)\n",
        "\n",
        "# Wyświetlanie opisu, listy audio, podglądu i przycisków pobierania\n",
        "display(audio_selection_description, selected_audio, output_audio_widget, download_selected_button, download_all_button)\n",
        "print()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ktxyJ-PxG-ue"
      },
      "source": [
        "# TEST ❌"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Y_ka_MLkZ46E"
      },
      "outputs": [],
      "source": [
        "# @title ElevenLabs Infinite TTS API Generator v1 { run: \"auto\" }\n",
        "\n",
        "import ipywidgets as widgets\n",
        "import IPython.display as ipd\n",
        "import requests\n",
        "import os\n",
        "import zipfile\n",
        "# from elevenlabs import voices, set_api_key\n",
        "from IPython.display import clear_output, display, HTML\n",
        "\n",
        "# Domyślne ścieżki\n",
        "default_path = \"/content/\"\n",
        "\n",
        "# Sprawdź i przypisz None, jeśli zmienne nie istnieją\n",
        "if 'google_drive_path' not in locals():\n",
        "    google_drive_path = None\n",
        "if 'github_repo_path' not in locals():\n",
        "    github_repo_path = None\n",
        "\n",
        "# Funkcja: Sprawdź dostępne ścieżki i zwróć listę\n",
        "def get_available_paths():\n",
        "    available_paths = []\n",
        "\n",
        "    if os.path.exists(default_path):\n",
        "        available_paths.append('Google Colab')\n",
        "    if google_drive_path is not None:\n",
        "        available_paths.append('Google Drive')\n",
        "    if github_repo_path is not None:\n",
        "        available_paths.append('GitHub')\n",
        "\n",
        "    return available_paths\n",
        "\n",
        "# Funkcja: Aktualizuj ścieżkę na podstawie wyboru\n",
        "def update_folder(change):\n",
        "    new_path = default_path\n",
        "\n",
        "    if change.new == 'Google Drive' and google_drive_path is not None:\n",
        "        new_path = google_drive_path\n",
        "    if change.new == 'GitHub' and github_repo_path is not None:\n",
        "        new_path = github_repo_path\n",
        "\n",
        "    %cd $new_path\n",
        "\n",
        "# Pobierz dostępne ścieżki\n",
        "available_paths = get_available_paths()\n",
        "\n",
        "# Dodaj opcję \"Google Colab\" do listy dostępnych ścieżek, jeśli nie istnieje\n",
        "if 'Google Colab' not in available_paths:\n",
        "    available_paths.append('Google Colab')\n",
        "\n",
        "# Stwórz przycisk typu radio do wyboru folderu z dostępnymi ścieżkami\n",
        "folder_radio = widgets.RadioButtons(\n",
        "    options=available_paths,\n",
        "    description='Lokalizacja:',\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "# Uaktualnij ścieżkę na podstawie wyboru\n",
        "folder_radio.observe(update_folder, 'value')\n",
        "\n",
        "audio_files = []\n",
        "CHUNK_SIZE = 2048\n",
        "\n",
        "# Stwórz folder wyjściowy\n",
        "output_dir = 'output_audio'\n",
        "os.makedirs(output_dir, exist_ok=True)\n",
        "\n",
        "api_key_widget = widgets.Dropdown(\n",
        "    options=[(key['description'], key['key']) for key in api_keys],\n",
        "    description=\"Klucz API:\"\n",
        ")\n",
        "\n",
        "def set_api_and_refresh(change):\n",
        "    try:\n",
        "        selected_key = next(key for key in api_keys if key['key'] == api_key_widget.value)\n",
        "        set_api_key(selected_key['key'])\n",
        "        refresh_voices_and_clear_ui()\n",
        "    except Exception as e:\n",
        "        clear_output()\n",
        "        display(HTML('<h1>ElevenLabs TTS API Google Colab</h1>'))\n",
        "        display(api_key_widget)\n",
        "        display(HTML(f'<p style=\"color: red;\">Błąd: Nieprawidłowy klucz API</p>'))\n",
        "\n",
        "api_key_widget.observe(set_api_and_refresh, names='value')\n",
        "\n",
        "def refresh_voices_and_clear_ui():\n",
        "    clear_output()\n",
        "    display(HTML('<h1>ElevenLabs Infinite TTS API Generator</h1>'))\n",
        "    set_api_key(api_key_widget.value)\n",
        "\n",
        "    # Pobranie dostępnych głosów\n",
        "    available_voices = voices()\n",
        "    voice_options = sorted([\n",
        "        (\n",
        "            f\"{voice.name} ({voice.category}) - {voice.labels['accent']}\" + (f\", {voice.labels['description']}\" if 'description' in voice.labels else \"\") + f\", {voice.labels['age']}, {voice.labels['gender']}\" + (f\", {voice.labels['use case']}\" if 'use case' in voice.labels else \"\"),\n",
        "            voice.voice_id\n",
        "        )\n",
        "        for voice in available_voices.voices\n",
        "    ])\n",
        "\n",
        "    selected_voice = widgets.Dropdown(\n",
        "        options=voice_options,\n",
        "        description=\"Głos:\"\n",
        "    )\n",
        "\n",
        "    def update_url_and_headers(change):\n",
        "        global url, headers\n",
        "        url = f\"https://api.elevenlabs.io/v1/text-to-speech/{selected_voice.value}\"\n",
        "        headers = {\n",
        "            \"Accept\": \"audio/mpeg\",\n",
        "            \"Content-Type\": \"application/json\",\n",
        "            \"xi-api-key\": api_key_widget.value\n",
        "        }\n",
        "\n",
        "    selected_voice.observe(update_url_and_headers, names='value')\n",
        "    update_url_and_headers(None)  # Inicjalizacja url i headers\n",
        "\n",
        "    # Interaktywne widgety do konfiguracji generowania dźwięku\n",
        "    text_widget = widgets.Textarea(\n",
        "        value=\"OK\",  # Domyślny tekst\n",
        "        description=\"Tekst:\",\n",
        "        rows=5,\n",
        "        layout=widgets.Layout(width=\"90%\", height=\"150px\"),\n",
        "        max_chars=5000\n",
        "    )\n",
        "\n",
        "    model_id_widget = widgets.Dropdown(\n",
        "        options=[\"eleven_monolingual_v1\", \"eleven_multilingual_v1\", \"eleven_multilingual_v2\"],\n",
        "        value=\"eleven_multilingual_v2\",\n",
        "        description=\"ID modelu:\"\n",
        "    )\n",
        "\n",
        "    stability_widget = widgets.FloatSlider(\n",
        "        value=0.5,\n",
        "        min=0.0,\n",
        "        max=1.0,\n",
        "        step=0.01,  # Zmieniony krok suwaka na 0.01\n",
        "        description=\"Stabilność:\"\n",
        "    )\n",
        "\n",
        "    similarity_boost_widget = widgets.FloatSlider(\n",
        "        value=0.75,\n",
        "        min=0.0,\n",
        "        max=1.0,\n",
        "        step=0.01,  # Zmieniony krok suwaka na 0.01\n",
        "        description=\"Podobność:\"\n",
        "    )\n",
        "\n",
        "    style_widget = widgets.FloatSlider(\n",
        "        value=0.0,\n",
        "        min=0.0,\n",
        "        max=1.0,\n",
        "        step=0.01,  # Zmieniony krok suwaka na 0.01\n",
        "        description=\"Styl:\"\n",
        "    )\n",
        "\n",
        "    use_speaker_boost_widget = widgets.RadioButtons(\n",
        "        options=[(\"Tak\", True), (\"Nie\", False)],\n",
        "        value=True,\n",
        "        description=\"Przesilenie:\"\n",
        "    )\n",
        "\n",
        "    # Funkcja do pobierania pliku audio\n",
        "    def create_unique_filename(output_dir, counter):\n",
        "        while True:\n",
        "            filename = os.path.join(output_dir, f\"{counter:05d}.mp3\")\n",
        "            if not os.path.exists(filename):\n",
        "                return filename\n",
        "            counter += 1\n",
        "\n",
        "    audio_files = sorted([filename for filename in os.listdir('output_audio') if filename.endswith('.mp3')])\n",
        "\n",
        "    def download_audio(b):\n",
        "        global audio_files\n",
        "        data = {\n",
        "            \"text\": text_widget.value,\n",
        "            \"model_id\": model_id_widget.value,\n",
        "            \"voice_settings\": {\n",
        "                \"stability\": stability_widget.value,\n",
        "                \"similarity_boost\": similarity_boost_widget.value,\n",
        "                \"style\": style_widget.value,\n",
        "                \"use_speaker_boost\": use_speaker_boost_widget.value\n",
        "\n",
        "            }\n",
        "        }\n",
        "\n",
        "        response = requests.post(url, json=data, headers=headers)\n",
        "\n",
        "        output_filename = create_unique_filename(output_dir, len(audio_files) + 1)\n",
        "\n",
        "        with open(output_filename, 'wb') as f:\n",
        "            for chunk in response.iter_content(chunk_size=CHUNK_SIZE):\n",
        "                if chunk:\n",
        "                    f.write(chunk)\n",
        "\n",
        "        audio_files.append(os.path.basename(output_filename))\n",
        "        selected_audio.options = audio_files\n",
        "        selected_audio.value = [os.path.basename(output_filename)]\n",
        "\n",
        "    button = widgets.Button(description=\"Wygeneruj Audio\", layout=widgets.Layout(width=\"300px\", height=\"30px\"))\n",
        "    output_audio_widget = widgets.Output()\n",
        "    button.on_click(download_audio)\n",
        "\n",
        "    # Wyświetlanie opisu, listy audio, podglądu i przycisków pobierania\n",
        "    selected_audio = widgets.SelectMultiple(\n",
        "        options=audio_files,\n",
        "        description='',\n",
        "        disabled=False\n",
        "    )\n",
        "\n",
        "    audio_selection_description = widgets.HTML('<h3>Zaznacz Audio Do Pobrania - (Ctrl / Shift + Click)</h3>')\n",
        "\n",
        "    output_audio_widget = widgets.Output()\n",
        "\n",
        "    def display_selected_audio(change):\n",
        "        with output_audio_widget:\n",
        "            output_audio_widget.clear_output()\n",
        "            selected_files = selected_audio.value\n",
        "            if len(selected_files) == 1:\n",
        "                filename = selected_files[0]\n",
        "                audio_path = os.path.join(output_dir, filename)\n",
        "                display(HTML(f'<h3>Plik: {filename}</h3>'))\n",
        "                audio_display = ipd.Audio(audio_path, autoplay=True)  # Automatyczne odtwarzanie\n",
        "                display(audio_display)\n",
        "            else:\n",
        "                for filename in selected_files:\n",
        "                    audio_path = os.path.join(output_dir, filename)\n",
        "                    display(HTML(f'<h3>Plik: {filename}</h3>'))\n",
        "                    audio_display = ipd.Audio(audio_path)\n",
        "                    display(audio_display)\n",
        "\n",
        "    selected_audio.observe(display_selected_audio, names='value')\n",
        "\n",
        "    download_selected_button = widgets.Button(description='Pobierz Zaznaczone',\n",
        "                                              layout=widgets.Layout(width='300px', height='30px'))\n",
        "\n",
        "    download_all_button = widgets.Button(description='Pobierz Wszystko',\n",
        "                                        layout=widgets.Layout(width='300px', height='30px'))\n",
        "\n",
        "    def download_selected_audio(b):\n",
        "        selected_files = selected_audio.value\n",
        "        zip_filename = os.path.join(output_dir, 'selected_audio.zip')\n",
        "        with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
        "            for filename in selected_files:\n",
        "                audio_path = os.path.join(output_dir, filename)\n",
        "                zipf.write(audio_path, os.path.basename(audio_path))\n",
        "        files.download(zip_filename)\n",
        "\n",
        "    def download_all_audio(b):\n",
        "        zip_filename = os.path.join(output_dir, 'all_audio.zip')\n",
        "        with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
        "            for filename in audio_files:\n",
        "                audio_path = os.path.join(output_dir, filename)\n",
        "                zipf.write(audio_path, os.path.basename(audio_path))\n",
        "        files.download(zip_filename)\n",
        "\n",
        "    download_selected_button.on_click(download_selected_audio)\n",
        "    download_all_button.on_click(download_all_audio)\n",
        "\n",
        "    # Wyświetlanie opisu, listy audio, podglądu i przycisków pobierania\n",
        "    display(folder_radio,\n",
        "            api_key_widget,\n",
        "            selected_voice,\n",
        "            text_widget,\n",
        "            model_id_widget,\n",
        "            stability_widget,\n",
        "            similarity_boost_widget,\n",
        "            style_widget,\n",
        "            use_speaker_boost_widget,\n",
        "            button,\n",
        "            audio_selection_description,\n",
        "            selected_audio,\n",
        "            output_audio_widget,\n",
        "            download_selected_button,\n",
        "            download_all_button)\n",
        "\n",
        "display(api_key_widget)\n",
        "refresh_voices_and_clear_ui()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "sXUJcxiv9Xas"
      },
      "outputs": [],
      "source": [
        "# @title ElevenLabs Infinite TTS API Generator PODSTAWA { run: \"auto\" }\n",
        "\n",
        "import ipywidgets as widgets\n",
        "import IPython.display as ipd\n",
        "import requests\n",
        "import os\n",
        "import zipfile\n",
        "from elevenlabs import voices, set_api_key, Models\n",
        "from IPython.display import clear_output, display, HTML\n",
        "\n",
        "# Domyślne ścieżki\n",
        "default_path = \"/content/\"\n",
        "\n",
        "# Sprawdź i przypisz None, jeśli zmienne nie istnieją\n",
        "if 'google_drive_path' not in locals():\n",
        "    google_drive_path = None\n",
        "if 'github_repo_path' not in locals():\n",
        "    github_repo_path = None\n",
        "\n",
        "# Funkcja: Sprawdź dostępne ścieżki i zwróć listę\n",
        "def get_available_paths():\n",
        "    available_paths = []\n",
        "\n",
        "    if os.path.exists(default_path):\n",
        "        available_paths.append('Google Colab')\n",
        "    if google_drive_path is not None:\n",
        "        available_paths.append('Google Drive')\n",
        "    if github_repo_path is not None:\n",
        "        available_paths.append('GitHub')\n",
        "\n",
        "    return available_paths\n",
        "\n",
        "# Pobierz dostępne ścieżki\n",
        "available_paths = get_available_paths()\n",
        "\n",
        "# Dodaj opcję \"Google Colab\" do listy dostępnych ścieżek, jeśli nie istnieje\n",
        "if 'Google Colab' not in available_paths:\n",
        "    available_paths.append('Google Colab')\n",
        "\n",
        "# Stwórz przycisk typu radio do wyboru folderu z dostępnymi ścieżkami\n",
        "folder_radio = widgets.RadioButtons(\n",
        "    options=available_paths,\n",
        "    description='Lokalizacja:',\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "# Funkcja: Aktualizuj ścieżkę na podstawie wyboru\n",
        "def update_folder(change):\n",
        "    new_path = default_path\n",
        "\n",
        "    if change.new == 'Google Drive' and google_drive_path is not None:\n",
        "        new_path = google_drive_path\n",
        "    if change.new == 'GitHub' and github_repo_path is not None:\n",
        "        new_path = github_repo_path\n",
        "\n",
        "    %cd $new_path\n",
        "    refresh_output_audio_list()\n",
        "\n",
        "# Uaktualnij ścieżkę na podstawie wyboru\n",
        "folder_radio.observe(update_folder, 'value')\n",
        "\n",
        "\n",
        "# Stwórz folder wyjściowy\n",
        "output_dir = 'output_audio'\n",
        "os.makedirs(output_dir, exist_ok=True)\n",
        "\n",
        "api_key_widget = widgets.Dropdown(\n",
        "    options=[(key['description'], key['key']) for key in api_keys],\n",
        "    description=\"Klucz API:\"\n",
        ")\n",
        "\n",
        "\n",
        "def set_api_and_refresh(change):\n",
        "    try:\n",
        "        selected_key = next(\n",
        "            key for key in api_keys if key['key'] == api_key_widget.value)\n",
        "        set_api_key(selected_key['key'])\n",
        "        refresh_voices_and_clear_ui()\n",
        "    except Exception as e:\n",
        "        clear_output()\n",
        "        display(HTML('<h1>ElevenLabs TTS API Google Colab</h1>'))\n",
        "        display(api_key_widget)\n",
        "        display(HTML('<p style=\"color: red;\">Błąd: Nieprawidłowy klucz API</p>'))\n",
        "\n",
        "\n",
        "api_key_widget.observe(set_api_and_refresh, names='value')\n",
        "\n",
        "\n",
        "audio_files = []\n",
        "CHUNK_SIZE = 2048\n",
        "\n",
        "\n",
        "def refresh_voices_and_clear_ui():\n",
        "    clear_output()\n",
        "    display(HTML('<h1>ElevenLabs Infinite TTS API Generator</h1>'))\n",
        "    set_api_key(api_key_widget.value)\n",
        "\n",
        "    # Pobranie dostępnych głosów\n",
        "    available_voices = voices()\n",
        "    voice_options = sorted([\n",
        "        (\n",
        "            f\"{voice.name} ({voice.category}) - {voice.labels['accent']}\" + (f\", {voice.labels['description']}\" if 'description' in voice.labels else \"\") +\n",
        "            f\", {voice.labels['age']}, {voice.labels['gender']}\" +\n",
        "            (f\", {voice.labels['use case']}\" if 'use case' in voice.labels else \"\"),\n",
        "            voice.voice_id\n",
        "        )\n",
        "        for voice in available_voices.voices\n",
        "    ])\n",
        "\n",
        "    selected_voice = widgets.Dropdown(\n",
        "        options=voice_options,\n",
        "        description=\"Głos:\"\n",
        "    )\n",
        "\n",
        "    def update_url_and_headers(change):\n",
        "        global url, headers\n",
        "        url = f\"https://api.elevenlabs.io/v1/text-to-speech/{selected_voice.value}\"\n",
        "        headers = {\n",
        "            \"Accept\": \"audio/mpeg\",\n",
        "            \"Content-Type\": \"application/json\",\n",
        "            \"xi-api-key\": api_key_widget.value\n",
        "        }\n",
        "\n",
        "    selected_voice.observe(update_url_and_headers, names='value')\n",
        "    update_url_and_headers(None)  # Inicjalizacja url i headers\n",
        "\n",
        "    # Interaktywne widgety do konfiguracji generowania dźwięku\n",
        "    text_widget = widgets.Textarea(\n",
        "        value=\"OK\",  # Domyślny tekst\n",
        "        description=\"Tekst:\",\n",
        "        rows=5,\n",
        "        layout=widgets.Layout(width=\"90%\", height=\"150px\"),\n",
        "        max_chars=5000\n",
        "    )\n",
        "\n",
        "    # Pobranie listy modeli\n",
        "    models_list = Models.from_api()\n",
        "\n",
        "    # Tworzenie mapowania nazw modeli na ich identyfikatory\n",
        "    model_name_to_id = {\n",
        "        model.name: model.model_id for model in models_list.models}\n",
        "\n",
        "    # Tworzenie rozwijanej listy (dropdown) z nazwami modeli\n",
        "    model_name_widget = widgets.Dropdown(\n",
        "        # Przypisanie listy nazw jako opcje\n",
        "        options=[model.name for model in models_list.models],\n",
        "        value=models_list.models[0].name,  # Domyślnie wybrana nazwa modelu\n",
        "        description=\"Model:\"\n",
        "    )\n",
        "\n",
        "    stability_widget = widgets.FloatSlider(\n",
        "        value=0.5,\n",
        "        min=0.0,\n",
        "        max=1.0,\n",
        "        step=0.01,  # Zmieniony krok suwaka na 0.01\n",
        "        description=\"Stabilność:\"\n",
        "    )\n",
        "\n",
        "    similarity_boost_widget = widgets.FloatSlider(\n",
        "        value=0.75,\n",
        "        min=0.0,\n",
        "        max=1.0,\n",
        "        step=0.01,  # Zmieniony krok suwaka na 0.01\n",
        "        description=\"Podobność:\"\n",
        "    )\n",
        "\n",
        "    style_widget = widgets.FloatSlider(\n",
        "        value=0.0,\n",
        "        min=0.0,\n",
        "        max=1.0,\n",
        "        step=0.01,  # Zmieniony krok suwaka na 0.01\n",
        "        description=\"Styl:\"\n",
        "    )\n",
        "\n",
        "    use_speaker_boost_widget = widgets.RadioButtons(\n",
        "        options=[(\"Tak\", True), (\"Nie\", False)],\n",
        "        value=True,\n",
        "        description=\"Przesilenie:\"\n",
        "    )\n",
        "\n",
        "    # Funkcja do pobierania pliku audio\n",
        "    def create_unique_filename(output_dir, counter):\n",
        "        while True:\n",
        "            filename = os.path.join(output_dir, f\"{counter:05d}.mp3\")\n",
        "            if not os.path.exists(filename):\n",
        "                return filename\n",
        "            counter += 1\n",
        "\n",
        "    def refresh_output_audio_list():\n",
        "        global audio_files\n",
        "        audio_files = sorted([filename for filename in os.listdir(\n",
        "            output_dir) if filename.endswith('.mp3')])\n",
        "\n",
        "    def download_audio(b):\n",
        "        refresh_output_audio_list()\n",
        "        data = {\n",
        "            \"text\": text_widget.value,\n",
        "            \"model_id\": model_name_to_id[model_name_widget.value],\n",
        "            \"voice_settings\": {\n",
        "                \"stability\": stability_widget.value,\n",
        "                \"similarity_boost\": similarity_boost_widget.value,\n",
        "                \"style\": style_widget.value,\n",
        "                \"use_speaker_boost\": use_speaker_boost_widget.value\n",
        "\n",
        "            }\n",
        "        }\n",
        "\n",
        "        response = requests.post(url, json=data, headers=headers)\n",
        "\n",
        "        output_filename = create_unique_filename(\n",
        "            output_dir, len(audio_files) + 1)\n",
        "\n",
        "        with open(output_filename, 'wb') as f:\n",
        "            for chunk in response.iter_content(chunk_size=CHUNK_SIZE):\n",
        "                if chunk:\n",
        "                    f.write(chunk)\n",
        "\n",
        "        audio_files.append(os.path.basename(output_filename))\n",
        "        selected_audio.options = audio_files\n",
        "        selected_audio.value = [os.path.basename(output_filename)]\n",
        "\n",
        "    button = widgets.Button(description=\"Wygeneruj Audio\",\n",
        "                            layout=widgets.Layout(width=\"300px\", height=\"30px\"))\n",
        "    output_audio_widget = widgets.Output()\n",
        "    button.on_click(download_audio)\n",
        "\n",
        "    # Wyświetlanie opisu, listy audio, podglądu i przycisków pobierania\n",
        "    selected_audio = widgets.SelectMultiple(\n",
        "        options=audio_files,\n",
        "        description='',\n",
        "        disabled=False\n",
        "    )\n",
        "\n",
        "    audio_selection_description = widgets.HTML(\n",
        "        '<h3>Zaznacz Audio Do Pobrania - (Ctrl / Shift + Click)</h3>')\n",
        "\n",
        "    output_audio_widget = widgets.Output()\n",
        "\n",
        "    def display_selected_audio(change):\n",
        "        with output_audio_widget:\n",
        "            output_audio_widget.clear_output()\n",
        "            selected_files = selected_audio.value\n",
        "            if len(selected_files) == 1:\n",
        "                filename = selected_files[0]\n",
        "                audio_path = os.path.join(output_dir, filename)\n",
        "                display(HTML(f'<h3>Plik: {filename}</h3>'))\n",
        "                # Automatyczne odtwarzanie\n",
        "                audio_display = ipd.Audio(audio_path, autoplay=True)\n",
        "                display(audio_display)\n",
        "            else:\n",
        "                for filename in selected_files:\n",
        "                    audio_path = os.path.join(output_dir, filename)\n",
        "                    display(HTML(f'<h3>Plik: {filename}</h3>'))\n",
        "                    audio_display = ipd.Audio(audio_path)\n",
        "                    display(audio_display)\n",
        "\n",
        "    selected_audio.observe(display_selected_audio, names='value')\n",
        "\n",
        "    download_selected_button = widgets.Button(description='Pobierz Zaznaczone',\n",
        "                                              layout=widgets.Layout(width='300px', height='30px'))\n",
        "\n",
        "    download_all_button = widgets.Button(description='Pobierz Wszystko',\n",
        "                                         layout=widgets.Layout(width='300px', height='30px'))\n",
        "\n",
        "    def download_selected_audio(b):\n",
        "        selected_files = selected_audio.value\n",
        "        zip_filename = os.path.join(output_dir, 'selected_audio.zip')\n",
        "        with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
        "            for filename in selected_files:\n",
        "                audio_path = os.path.join(output_dir, filename)\n",
        "                zipf.write(audio_path, os.path.basename(audio_path))\n",
        "        files.download(zip_filename)\n",
        "\n",
        "    def download_all_audio(b):\n",
        "        zip_filename = os.path.join(output_dir, 'all_audio.zip')\n",
        "        with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
        "            for filename in audio_files:\n",
        "                audio_path = os.path.join(output_dir, filename)\n",
        "                zipf.write(audio_path, os.path.basename(audio_path))\n",
        "        files.download(zip_filename)\n",
        "\n",
        "    download_selected_button.on_click(download_selected_audio)\n",
        "    download_all_button.on_click(download_all_audio)\n",
        "\n",
        "    # Wyświetlanie opisu, listy audio, podglądu i przycisków pobierania\n",
        "    display(folder_radio,\n",
        "            api_key_widget,\n",
        "            selected_voice,\n",
        "            text_widget,\n",
        "            model_name_widget,\n",
        "            stability_widget,\n",
        "            similarity_boost_widget,\n",
        "            style_widget,\n",
        "            use_speaker_boost_widget,\n",
        "            button,\n",
        "            audio_selection_description,\n",
        "            selected_audio,\n",
        "            output_audio_widget,\n",
        "            download_selected_button,\n",
        "            download_all_button)\n",
        "\n",
        "\n",
        "display(api_key_widget)\n",
        "refresh_voices_and_clear_ui()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "cYbqZz0dG9PZ"
      },
      "outputs": [],
      "source": [
        "# https://ipywidgets.readthedocs.io/en/stable/\n",
        "\n",
        "# Ustawienie klucza API\n",
        "#@title Wpisz swój klucz API { run: \"auto\" }\n",
        "API = \"96028d102d0734fd815519ead6c6a625\" #@param {type:\"string\"}\n",
        "DISCRIPTION = \"mateuszmroz001@gmail.com\" #@param {type:\"string\"}\n",
        "\n",
        "api_keys = [\n",
        "    {\"key\": \"96028d102d0734fd815519ead6c6a625\", \"description\": \"mateuszmroz001@gmail.com\"},\n",
        "    {\"key\": \"69629e2241ca3f96a3e97587ad5072e5\", \"description\": \"eqdlaec669@fugmi.com\"},\n",
        "    {\"key\": \"klucz_api_3\", \"description\": \"Opis klucza API 3\"},\n",
        "    # Dodaj więcej kluczy API w podobny sposób\n",
        "]\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "SSVgpHoE1dGB"
      },
      "outputs": [],
      "source": [
        "# @title Przykład ze strony { run: \"auto\" }\n",
        "\n",
        "# import requests\n",
        "\n",
        "# # streaming chunk size\n",
        "# CHUNK_SIZE = 1024\n",
        "\n",
        "# XI_API_KEY = \"<xi-api-key>\"\n",
        "# VOICE_SAMPLE_PATH1 = \"<path-to-file>\"\n",
        "# VOICE_SAMPLE_PATH2 = \"<path-to-file>\"\n",
        "# OUTPUT_PATH = \"<path-to-file>\"\n",
        "\n",
        "# add_voice_url = \"https://api.elevenlabs.io/v1/voices/add\"\n",
        "\n",
        "# headers = {\n",
        "#   \"Accept\": \"application/json\",\n",
        "#   \"xi-api-key\": XI_API_KEY\n",
        "# }\n",
        "\n",
        "# data = {\n",
        "#     'name': 'Voice name',\n",
        "#     'labels': '{\"accent\": \"American\", \"gender\": \"Female\"}',\n",
        "#     'description': 'An old American male voice with a slight hoarseness in his throat. Perfect for news.'\n",
        "# }\n",
        "\n",
        "# files = [\n",
        "#     ('files', ('sample1.mp3', open(VOICE_SAMPLE_PATH1, 'rb'), 'audio/mpeg')),\n",
        "#     ('files', ('sample2.mp3', open(VOICE_SAMPLE_PATH2, 'rb'), 'audio/mpeg'))\n",
        "# ]\n",
        "\n",
        "# response = requests.post(add_voice_url, headers=headers, data=data, files=files)\n",
        "# voice_id = response.json()[\"voice_id\"]\n",
        "\n",
        "# # get default voice settings\n",
        "# response = requests.get(\n",
        "#     \"https://api.elevenlabs.io/v1/voices/settings/default\",\n",
        "#     headers={ \"Accept\": \"application/json\" }\n",
        "# ).json()\n",
        "# stability, similarity_boost = response[\"stability\"], response[\"similarity_boost\"]\n",
        "\n",
        "# tts_url = f\"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}/stream\"\n",
        "\n",
        "# headers[\"Content-Type\"] = \"application/json\"\n",
        "\n",
        "# data = {\n",
        "#   \"text\": \"Some very long text to be read by the voice\",\n",
        "#   \"model_id\": \"eleven_monolingual_v1\",\n",
        "#   \"voice_settings\": {\n",
        "#     \"stability\": stability,\n",
        "#     \"similarity_boost\": similarity_boost\n",
        "#   }\n",
        "# }\n",
        "\n",
        "# response = requests.post(tts_url, json=data, headers=headers, stream=True)\n",
        "\n",
        "# with open(OUTPUT_PATH, 'wb') as f:\n",
        "#     for chunk in response.iter_content(chunk_size=CHUNK_SIZE):\n",
        "#         if chunk:\n",
        "#             f.write(chunk)\n",
        "\n",
        "# # Retrieve history. It should contain generated sample.\n",
        "# history_url = \"https://api.elevenlabs.io/v1/history\"\n",
        "\n",
        "# headers = {\n",
        "#   \"Accept\": \"application/json\",\n",
        "#   \"xi-api-key\": XI_API_KEY\n",
        "# }\n",
        "\n",
        "# response = requests.get(history_url, headers=headers)\n",
        "\n",
        "# print(response.text)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# from elevenlabs import clone, generate, play, set_api_key\n",
        "# from elevenlabs.api import History\n",
        "\n",
        "# set_api_key(\"<YOUR_API_KEY>\")\n",
        "\n",
        "# voice = clone(\n",
        "#     name=\"Voice Name\",\n",
        "#     description=\"An old American male voice with a slight hoarseness in his throat. Perfect for news.\",\n",
        "#     files=[\"./sample1.mp3\", \"./sample2.mp3\"],\n",
        "# )\n",
        "\n",
        "# audio = generate(text=\"Some very long text to be read by the voice\", voice=voice)\n",
        "\n",
        "# play(audio)\n",
        "\n",
        "# history = History.from_api()\n",
        "# print(history)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# # zamiana tekstu na mowe\n",
        "# import requests\n",
        "\n",
        "# CHUNK_SIZE = 1024\n",
        "# url = \"https://api.elevenlabs.io/v1/text-to-speech/<voice-id>\"\n",
        "\n",
        "# headers = {\n",
        "#   \"Accept\": \"audio/mpeg\",\n",
        "#   \"Content-Type\": \"application/json\",\n",
        "#   \"xi-api-key\": \"<xi-api-key>\"\n",
        "# }\n",
        "\n",
        "# data = {\n",
        "#   \"text\": \"Hi! My name is Bella, nice to meet you!\",\n",
        "#   \"model_id\": \"eleven_monolingual_v1\",\n",
        "#   \"voice_settings\": {\n",
        "#     \"stability\": 0.5,\n",
        "#     \"similarity_boost\": 0.5\n",
        "#   }\n",
        "# }\n",
        "\n",
        "# response = requests.post(url, json=data, headers=headers)\n",
        "# with open('output.mp3', 'wb') as f:\n",
        "#     for chunk in response.iter_content(chunk_size=CHUNK_SIZE):\n",
        "#         if chunk:\n",
        "#             f.write(chunk)\n",
        "\n",
        "\n",
        "\n",
        "# strumieniuj tekst na mowe\n",
        "\n",
        "import requests\n",
        "\n",
        "CHUNK_SIZE = 1024\n",
        "url = \"https://api.elevenlabs.io/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL/stream\"\n",
        "\n",
        "headers = {\n",
        "  \"Accept\": \"audio/mpeg\",\n",
        "  \"Content-Type\": \"application/json\",\n",
        "  \"xi-api-key\": \"4d88c7168ddf8a163ffbf176276e72c5\"\n",
        "}\n",
        "\n",
        "data = {\n",
        "  \"text\": \"Hi! My name is Bella, nice to meet you!\",\n",
        "  \"model_id\": \"eleven_monolingual_v1\",\n",
        "  \"voice_settings\": {\n",
        "    \"stability\": 0.5,\n",
        "    \"similarity_boost\": 0.5\n",
        "  }\n",
        "}\n",
        "\n",
        "response = requests.post(url, json=data, headers=headers, stream=True)\n",
        "\n",
        "with open('output.mp3', 'wb') as f:\n",
        "    for chunk in response.iter_content(chunk_size=CHUNK_SIZE):\n",
        "        if chunk:\n",
        "            f.write(chunk)\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gqXyEgF82-Jg"
      },
      "outputs": [],
      "source": [
        "# @title BUTTON { run: \"auto\" }\n",
        "\n",
        "execute_button = widgets.Button(\n",
        "    description='Wykonaj',\n",
        "    style=dict(font_weight='bold'),\n",
        "    layout=widgets.Layout(width='300px', height='30px')\n",
        ")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "ovcUnKJZFngJ"
      },
      "outputs": [],
      "source": [
        "#@title Komentarze w GC\n",
        "\n",
        "import ipywidgets as widgets\n",
        "\n",
        "# @title: Tytuł Notatnika\n",
        "# Ustawia tytuł notatnika.\n",
        "# @title Przykładowy Tytuł\n",
        "\n",
        "# @markdown: Tekst w formie Markdown\n",
        "# Pozwala na wstawienie tekstu w formie Markdown do notatnika.\n",
        "# Przykład:\n",
        "# @markdown ## Instrukcje\n",
        "\n",
        "# Ten notatnik zawiera przykładowy tekst w formie Markdown.\n",
        "\n",
        "# @param: Interaktywny parametr\n",
        "# Tworzy interaktywny parametr, który użytkownik może dostosować.\n",
        "# Przykład:\n",
        "@param {type:\"slider\", min:0, max:100, step:1, default:50} wartość_slidera\n",
        "wartość_slidera = 26 # @param {type:\"slider\", min:0, max:100, step:1, default:50}\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r3gH1yw7rjYC"
      },
      "source": [
        "## DZIAŁA"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "AI9bkD2di13u"
      },
      "outputs": [],
      "source": [
        "# @title 2.1 Dodaj / Usuń Klucz API w Google Drive { run: \"auto\" }\n",
        "\n",
        "# Importowanie niezbędnych modułów\n",
        "import os\n",
        "import json\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import display\n",
        "import requests\n",
        "\n",
        "# Ścieżka do katalogu i pliku JSON przechowującego klucze API\n",
        "directory_path = '/content/drive/MyDrive/11Labs_TTS_Colab/'\n",
        "file_name = 'elevenlabs_api_keys.json'\n",
        "file_path = os.path.join(directory_path, file_name)\n",
        "\n",
        "# Funkcja do wczytywania kluczy API z pliku\n",
        "def load_api_keys():\n",
        "    try:\n",
        "        with open(file_path, 'r') as file:\n",
        "            return json.load(file)\n",
        "    except FileNotFoundError:\n",
        "        return []\n",
        "\n",
        "# Funkcja do zapisu kluczy API do pliku\n",
        "def save_api_keys(keys):\n",
        "    with open(file_path, 'w') as file:\n",
        "        # Dodanie argumentu 'indent' do formatowania\n",
        "        json.dump(keys, file, indent=4)\n",
        "\n",
        "# Funkcja do wywołania API i obliczenia pozostałych znaków\n",
        "def call_api_and_calculate_remaining_characters(api_key):\n",
        "    try:\n",
        "        url = \"https://api.elevenlabs.io/v1/user\"\n",
        "        headers = {\n",
        "            \"Accept\": \"application/json\",\n",
        "            \"xi-api-key\": api_key\n",
        "        }\n",
        "        response = requests.get(url, headers=headers)\n",
        "        response_data = response.json()\n",
        "        character_limit = response_data['subscription']['character_limit']\n",
        "        character_count = response_data['subscription']['character_count']\n",
        "        return character_limit - character_count\n",
        "    except (requests.exceptions.RequestException, KeyError, json.JSONDecodeError) as e:\n",
        "        print(\"Wystąpił błąd podczas wywoływania API:\", e)\n",
        "        return None\n",
        "\n",
        "# Obszar tekstowy do wyświetlania informacji o wybranym kluczu\n",
        "key_info_output = widgets.Output()\n",
        "\n",
        "# Wczytanie istniejących kluczy API\n",
        "api_keys = load_api_keys()\n",
        "\n",
        "# Funkcja do wyświetlania informacji o wybranym kluczu w obszarze tekstowym\n",
        "def show_key_info(selected_key):\n",
        "    key_info_output.clear_output()\n",
        "    with key_info_output:\n",
        "        if selected_key is not None:  # Dodano warunek sprawdzający, czy selected_key nie jest None\n",
        "            print(f\"ID: {selected_key['id']}\")\n",
        "            print(f\"Key: {selected_key['key']}\")\n",
        "            print(f\"Description: {selected_key['description']}\")\n",
        "            if 'remaining_characters' in selected_key:\n",
        "                print(\n",
        "                    f\"Remaining Characters: {selected_key['remaining_characters']}\")\n",
        "\n",
        "# Funkcja aktualizująca i zapisująca pozostałe znaki do pliku JSON po wywołaniu API\n",
        "def update_and_save_remaining_characters(api_key):\n",
        "    if api_key is None:\n",
        "        return\n",
        "    try:\n",
        "        remaining_characters = call_api_and_calculate_remaining_characters(\n",
        "            api_key)\n",
        "        if remaining_characters is not None:\n",
        "            for key in api_keys:\n",
        "                if key['key'] == api_key:\n",
        "                    key['remaining_characters'] = remaining_characters\n",
        "                    break\n",
        "            save_api_keys(api_keys)\n",
        "            # Aktualizacja informacji o wybranym kluczu\n",
        "            show_key_info(key_info_dropdown.value)\n",
        "    except Exception as e:\n",
        "        print(\"Wystąpił błąd podczas aktualizowania pozostałych znaków:\", e)\n",
        "\n",
        "\n",
        "# Funkcja do generowania nowego ID\n",
        "def generate_new_id(api_keys):\n",
        "    return max(key['id'] for key in api_keys) + 1 if api_keys else 1\n",
        "\n",
        "\n",
        "# Tworzenie interaktywnego przycisku wyboru akcji: Dodaj klucz API / Usuń klucz API\n",
        "action_radio = widgets.RadioButtons(\n",
        "    options=['Dodaj klucz API', 'Usuń klucz API'],\n",
        "    description='Akcja:'\n",
        ")\n",
        "\n",
        "# Tworzenie rozwijanej listy opcji dla istniejących kluczy API\n",
        "key_info_dropdown = widgets.Dropdown(\n",
        "    options=[(f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key)\n",
        "             for key in api_keys],\n",
        "    description='Wybierz:',\n",
        "    value=api_keys[0] if api_keys else None\n",
        ")\n",
        "\n",
        "# Obszar tekstowy do wyświetlania informacji o wybranym kluczu\n",
        "key_info_output = widgets.Output()\n",
        "\n",
        "# Iteracja przez istniejące klucze API i aktualizacja pozostałych znaków\n",
        "for key in api_keys:\n",
        "    update_and_save_remaining_characters(key['key'])\n",
        "\n",
        "# Funkcja wywoływana po zmianie wyboru w rozwijanej liście\n",
        "def key_info_dropdown_change(change):\n",
        "    if change['type'] == 'change' and change['name'] == 'value':\n",
        "        if change['new'] in api_keys:\n",
        "            selected_key = change['new']\n",
        "            show_key_info(selected_key)\n",
        "            if selected_key is not None:\n",
        "                # Aktualizacja pozostałych znaków po zmianie klucza\n",
        "                update_and_save_remaining_characters(selected_key['key'])\n",
        "\n",
        "                # Aktualizacja listy rozwijanej po wyborze klucza\n",
        "                key_info_dropdown.options = [\n",
        "                    (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key) for key in api_keys]\n",
        "                key_info_dropdown.value = selected_key  # Ustawienie wybranego klucza\n",
        "\n",
        "key_info_dropdown.observe(key_info_dropdown_change)\n",
        "\n",
        "# Przycisk do wykonania wybranej akcji\n",
        "execute_button = widgets.Button(\n",
        "    description='Wykonaj',\n",
        "    style=dict(font_weight='bold'),\n",
        "    layout=widgets.Layout(width='300px', height='30px')\n",
        ")\n",
        "\n",
        "# Funkcja wywoływana po kliknięciu przycisku \"Wykonaj\"\n",
        "def execute_action(button):\n",
        "    selected_action = action_radio.value\n",
        "    if selected_action == 'Dodaj klucz API':\n",
        "        new_key = new_key_text.value\n",
        "        new_description = new_description_text.value\n",
        "        if new_key and new_description:\n",
        "            try:\n",
        "                # Sprawdzenie, czy nowy klucz API lub opis nie są już w użyciu\n",
        "                if any(key['key'] == new_key or key['description'] == new_description for key in api_keys):\n",
        "                    print(\n",
        "                        \"Klucz API lub opis się powtarzają. Proszę wybrać unikalne wartości.\")\n",
        "                else:\n",
        "                    new_id = generate_new_id(api_keys)\n",
        "                    api_keys.append(\n",
        "                        {\"id\": new_id, \"key\": new_key, \"description\": new_description})\n",
        "                    save_api_keys(api_keys)\n",
        "                    print(\"Nowy klucz API został dodany.\")\n",
        "                    key_info_dropdown.options = [\n",
        "                        (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key) for key in api_keys]\n",
        "\n",
        "                    # Znalezienie i zaznaczenie ostatnio dodanego klucza w opcjach rozwijanej listy\n",
        "                    for option in key_info_dropdown.options:\n",
        "                        if option[1]['id'] == new_id:\n",
        "                            key_info_dropdown.value = option[1]\n",
        "                            break\n",
        "\n",
        "                    # Aktualizacja pozostałych znaków po dodaniu nowego klucza\n",
        "                    update_and_save_remaining_characters(new_key)\n",
        "\n",
        "                    # Odświeżanie ilości znaków dla wybranego klucza\n",
        "                    selected_key = key_info_dropdown.value\n",
        "                    if selected_key is not None:\n",
        "                        update_and_save_remaining_characters(\n",
        "                            selected_key['key'])\n",
        "            except Exception as e:\n",
        "                print(\"Wystąpił błąd podczas dodawania klucza API:\", e)\n",
        "    elif selected_action == 'Usuń klucz API':\n",
        "        if key_info_dropdown.value is not None:\n",
        "            try:\n",
        "                selected_key = key_info_dropdown.value\n",
        "                key_id = selected_key['id']\n",
        "                for key in api_keys:\n",
        "                    if key['id'] == key_id:\n",
        "                        api_keys.remove(key)\n",
        "                        save_api_keys(api_keys)\n",
        "                        print(f\"Klucz API o ID '{key_id}' został usunięty.\")\n",
        "\n",
        "                        # Aktualizacja opcji rozwijanej listy po usunięciu klucza\n",
        "                        key_info_dropdown.options = [\n",
        "                            (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key) for key in api_keys]\n",
        "\n",
        "                        # Ustawienie selected_key na None po usunięciu klucza\n",
        "                        key_info_dropdown.value = None\n",
        "                        key_info_output.clear_output()  # Wyczyść obszar informacji o kluczu\n",
        "\n",
        "                        break\n",
        "            except Exception as e:\n",
        "                print(\"Wystąpił błąd podczas usuwania klucza API:\", e)\n",
        "        else:\n",
        "            print(\"Wybierz klucz do usunięcia.\")\n",
        "\n",
        "# Przypisanie funkcji do odpowiednich akcji po kliknięciu przycisku\n",
        "execute_button.on_click(execute_action)\n",
        "\n",
        "# Wyświetlenie interaktywnych widgetów\n",
        "display(action_radio)\n",
        "new_key_text = widgets.Text(description='Klucz API:')\n",
        "new_description_text = widgets.Text(description='Opis:')\n",
        "display(new_key_text)\n",
        "display(new_description_text)\n",
        "display(key_info_dropdown)\n",
        "display(key_info_output)\n",
        "display(execute_button)\n",
        "\n",
        "# [\n",
        "#     {\n",
        "#         \"id\": 1,\n",
        "#         \"key\": \"69629e2241ca3f96a3e97587ad5072e5\",\n",
        "#         \"description\": \"eqdlaec669@fugmi.com\",\n",
        "#         \"remaining_characters\": 376\n",
        "#     },\n",
        "#     {\n",
        "#         \"id\": 2,\n",
        "#         \"key\": \"96028d102d0734fd815519ead6c6a625\",\n",
        "#         \"description\": \"mateuszmroz001@gmail.com\",\n",
        "#         \"remaining_characters\": 4859\n",
        "#     },\n",
        "#     {\n",
        "#         \"id\": 3,\n",
        "#         \"key\": \"4d88c7168ddf8a163ffbf176276e72c5\",\n",
        "#         \"description\": \"mateuszmrozkun@gmail.com\",\n",
        "#         \"remaining_characters\": 10000\n",
        "#     },\n",
        "#     {\n",
        "#         \"id\": 4,\n",
        "#         \"key\": \"59f3ff34e070b562f8ac4f5847bf5f77\",\n",
        "#         \"description\": \"tojestpoprostutest@gmail.com\",\n",
        "#         \"remaining_characters\": 10000\n",
        "#     }\n",
        "# ]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "ZdOF3ZQBYRn3"
      },
      "outputs": [],
      "source": [
        "# @title 2.2 Dodaj / Usuń / Zapisz Klucze API Oraz Pliki Audio Do Repozytorium GitHub { run: \"auto\" }\n",
        "import os\n",
        "import json\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import display\n",
        "import requests\n",
        "import subprocess\n",
        "\n",
        "# Twój Personal Access Token\n",
        "token = token\n",
        "\n",
        "# Adres URL repozytorium\n",
        "repo_url = repo_url\n",
        "\n",
        "# Ścieżka do folderu, w którym znajduje się sklonowane repozytorium\n",
        "directory_path = github_repo_path\n",
        "\n",
        "# Konstrukcja URL z tokenem autoryzacyjnym\n",
        "auth_repo_url = auth_repo_url\n",
        "\n",
        "# Plik z kluczami API\n",
        "file_name = 'elevenlabs_api_keys.json'\n",
        "file_path = os.path.join(directory_path, file_name)\n",
        "\n",
        "# Funkcja do aktualizacji repozytorium na GitHubie\n",
        "def update_github_repo(commit_msg):\n",
        "    try:\n",
        "        # Przejście do odpowiedniego folderu\n",
        "        %cd {directory_path}\n",
        "        # print(f\"Przejście do: {directory_path}\")\n",
        "\n",
        "        # Ustawienie konfiguracji dla Git\n",
        "        # global_email = \"mateuszmroz@gmail.com\"  # Zaktualizuj na swoją wartość\n",
        "        # global_name = \"MattyMroz\"  # Zaktualizuj na swoją wartość\n",
        "        # !git config --global user.email \"{global_email}\"\n",
        "        # !git config --global user.name \"{global_name}\"\n",
        "        # print(\"Konfiguracja użytkownika Git zakończona!\")\n",
        "\n",
        "        # Dodawanie, commitowanie i wysyłanie zmian\n",
        "        print(\"Wysyłanie zmian do repozytorium:\")\n",
        "        !git add .\n",
        "        !git commit -m \"{commit_msg}\"\n",
        "        !git push origin main\n",
        "        print(\"Repozytorium zostało zaktualizowane na GitHubie.\")\n",
        "    except Exception as e:\n",
        "        print(\"Wystąpił błąd podczas aktualizowania repozytorium:\", e)\n",
        "\n",
        "# Funkcja do wczytywania kluczy API z pliku\n",
        "def load_api_keys():\n",
        "    try:\n",
        "        with open(file_path, 'r') as file:\n",
        "            return json.load(file)\n",
        "    except FileNotFoundError:\n",
        "        return []\n",
        "\n",
        "# Funkcja do zapisu kluczy API do pliku\n",
        "def save_api_keys(keys):\n",
        "    with open(file_path, 'w') as file:\n",
        "        # Dodanie argumentu 'indent' do formatowania\n",
        "        json.dump(keys, file, indent=4)\n",
        "\n",
        "# Funkcja do wywołania API i obliczenia pozostałych znaków\n",
        "def call_api_and_calculate_remaining_characters(api_key):\n",
        "    try:\n",
        "        url = \"https://api.elevenlabs.io/v1/user\"\n",
        "        headers = {\n",
        "            \"Accept\": \"application/json\",\n",
        "            \"xi-api-key\": api_key\n",
        "        }\n",
        "        response = requests.get(url, headers=headers)\n",
        "        response_data = response.json()\n",
        "        character_limit = response_data['subscription']['character_limit']\n",
        "        character_count = response_data['subscription']['character_count']\n",
        "        return character_limit - character_count\n",
        "    except (requests.exceptions.RequestException, KeyError, json.JSONDecodeError) as e:\n",
        "        print(\"Wystąpił błąd podczas wywoływania API:\", e)\n",
        "        return None\n",
        "\n",
        "# Wczytanie istniejących kluczy API\n",
        "api_keys = load_api_keys()\n",
        "\n",
        "# Funkcja do wyświetlania informacji o wybranym kluczu w obszarze tekstowym\n",
        "def show_key_info(selected_key):\n",
        "    key_info_output.clear_output()\n",
        "    with key_info_output:\n",
        "        if selected_key is not None:  # Dodano warunek sprawdzający, czy selected_key nie jest None\n",
        "            print(f\"ID: {selected_key['id']}\")\n",
        "            print(f\"Key: {selected_key['key']}\")\n",
        "            print(f\"Description: {selected_key['description']}\")\n",
        "            if 'remaining_characters' in selected_key:\n",
        "                print(\n",
        "                    f\"Remaining Characters: {selected_key['remaining_characters']}\")\n",
        "\n",
        "# Funkcja aktualizująca i zapisująca pozostałe znaki do pliku JSON po wywołaniu API\n",
        "def update_and_save_remaining_characters(api_key):\n",
        "    if api_key is None:\n",
        "        return\n",
        "    try:\n",
        "        remaining_characters = call_api_and_calculate_remaining_characters(\n",
        "            api_key)\n",
        "        if remaining_characters is not None:\n",
        "            for key in api_keys:\n",
        "                if key['key'] == api_key:\n",
        "                    key['remaining_characters'] = remaining_characters\n",
        "                    break\n",
        "            save_api_keys(api_keys)\n",
        "            # Aktualizacja informacji o wybranym kluczu\n",
        "            show_key_info(key_info_dropdown.value)\n",
        "    except Exception as e:\n",
        "        print(\"Wystąpił błąd podczas aktualizowania pozostałych znaków:\", e)\n",
        "\n",
        "# Funkcja do generowania nowego ID\n",
        "def generate_new_id(api_keys):\n",
        "    return max(key['id'] for key in api_keys) + 1 if api_keys else 1\n",
        "\n",
        "# Tworzenie interaktywnego przycisku wyboru akcji: Dodaj klucz API / Usuń klucz API\n",
        "action_radio = widgets.RadioButtons(\n",
        "    options=['Dodaj klucz API', 'Usuń klucz API'],\n",
        "    description='Akcja:'\n",
        ")\n",
        "\n",
        "# Tworzenie rozwijanej listy opcji dla istniejących kluczy API\n",
        "key_info_dropdown = widgets.Dropdown(\n",
        "    options=[(f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key)\n",
        "             for key in api_keys],\n",
        "    description='Wybierz:',\n",
        "    value=api_keys[0] if api_keys else None\n",
        ")\n",
        "\n",
        "# Obszar tekstowy do wyświetlania informacji o wybranym kluczu\n",
        "key_info_output = widgets.Output()\n",
        "\n",
        "# Iteracja przez istniejące klucze API i aktualizacja pozostałych znaków\n",
        "for key in api_keys:\n",
        "    update_and_save_remaining_characters(key['key'])\n",
        "\n",
        "# Funkcja wywoływana po zmianie wyboru w rozwijanej liście\n",
        "def key_info_dropdown_change(change):\n",
        "    if change['new'] in api_keys:\n",
        "        selected_key = change['new']\n",
        "        show_key_info(selected_key)\n",
        "        if selected_key is not None:\n",
        "            # Aktualizacja pozostałych znaków po zmianie klucza\n",
        "            update_and_save_remaining_characters(selected_key['key'])\n",
        "            update_github_repo(\"Zaktualizowano dane klucza API\")\n",
        "\n",
        "            # Aktualizacja listy rozwijanej po wyborze klucza\n",
        "            key_info_dropdown.options = [\n",
        "                (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key) for key in api_keys]\n",
        "            key_info_dropdown.value = selected_key  # Ustawienie wybranego klucza\n",
        "\n",
        "key_info_dropdown.observe(key_info_dropdown_change)\n",
        "\n",
        "# Przycisk do wykonania wybranej akcji\n",
        "execute_button = widgets.Button(\n",
        "    description='Wykonaj',\n",
        "    style=dict(font_weight='bold'),\n",
        "    layout=widgets.Layout(width='300px', height='30px')\n",
        ")\n",
        "\n",
        "# Funkcja wywoływana po kliknięciu przycisku \"Wykonaj\"\n",
        "def execute_action(button):\n",
        "    selected_action = action_radio.value\n",
        "    if selected_action == 'Dodaj klucz API':\n",
        "        new_key = new_key_text.value\n",
        "        new_description = new_description_text.value\n",
        "        if new_key and new_description:\n",
        "            try:\n",
        "                # Sprawdzenie, czy nowy klucz API lub opis nie są już w użyciu\n",
        "                if any(key['key'] == new_key or key['description'] == new_description for key in api_keys):\n",
        "                    print(\n",
        "                        \"Klucz API lub opis się powtarzają. Proszę wybrać unikalne wartości.\")\n",
        "                else:\n",
        "                    new_id = generate_new_id(api_keys)\n",
        "                    api_keys.append(\n",
        "                        {\"id\": new_id, \"key\": new_key, \"description\": new_description})\n",
        "                    save_api_keys(api_keys)\n",
        "                    print(\"Nowy klucz API został dodany.\")\n",
        "                    key_info_dropdown.options = [\n",
        "                        (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key) for key in api_keys]\n",
        "\n",
        "                    # Znalezienie i zaznaczenie ostatnio dodanego klucza w opcjach rozwijanej listy\n",
        "                    for option in key_info_dropdown.options:\n",
        "                        if option[1]['id'] == new_id:\n",
        "                            key_info_dropdown.value = option[1]\n",
        "                            break\n",
        "\n",
        "                    # Aktualizacja pozostałych znaków po dodaniu nowego klucza\n",
        "                    update_and_save_remaining_characters(new_key)\n",
        "\n",
        "                    # Odświeżanie ilości znaków dla wybranego klucza\n",
        "                    selected_key = key_info_dropdown.value\n",
        "                    if selected_key is not None:\n",
        "                        update_and_save_remaining_characters(\n",
        "                            selected_key['key'])\n",
        "                update_github_repo(\"Dodano klucz API\")\n",
        "            except Exception as e:\n",
        "                print(\"Wystąpił błąd podczas dodawania klucza API:\", e)\n",
        "    elif selected_action == 'Usuń klucz API':\n",
        "        if key_info_dropdown.value is not None:\n",
        "            try:\n",
        "                selected_key = key_info_dropdown.value\n",
        "                key_id = selected_key['id']\n",
        "                for key in api_keys:\n",
        "                    if key['id'] == key_id:\n",
        "                        api_keys.remove(key)\n",
        "                        save_api_keys(api_keys)\n",
        "                        print(f\"Klucz API o ID '{key_id}' został usunięty.\")\n",
        "\n",
        "                        # Aktualizacja opcji rozwijanej listy po usunięciu klucza\n",
        "                        key_info_dropdown.options = [\n",
        "                            (f\"ID: {key['id']}, Desc: {key['description']}, RC: {key.get('remaining_characters', 'N/A')}\", key) for key in api_keys]\n",
        "\n",
        "                        # Ustawienie selected_key na None po usunięciu klucza\n",
        "                        key_info_dropdown.value = None\n",
        "                        key_info_output.clear_output()  # Wyczyść obszar informacji o kluczu\n",
        "\n",
        "                        break\n",
        "                update_github_repo(\"Usunięto klucz API\")\n",
        "            except Exception as e:\n",
        "                print(\"Wystąpił błąd podczas usuwania klucza API:\", e)\n",
        "        else:\n",
        "            print(\"Wybierz klucz do usunięcia.\")\n",
        "\n",
        "# Przypisanie funkcji do odpowiednich akcji po kliknięciu przycisku\n",
        "execute_button.on_click(execute_action)\n",
        "\n",
        "\n",
        "# Wyświetlenie interaktywnych widgetów\n",
        "display(action_radio)\n",
        "new_key_text = widgets.Text(description='Klucz API:')\n",
        "new_description_text = widgets.Text(description='Opis:')\n",
        "display(new_key_text)\n",
        "display(new_description_text)\n",
        "display(key_info_dropdown)\n",
        "display(key_info_output)\n",
        "display(execute_button)\n",
        "\n",
        "# Aktualizacja repozytorium na GitHubie z odpowiednim komunikatem\n",
        "update_github_repo(\"Automatyczna aktualizacja pozostałych znaków\")\n",
        "\n",
        "# [\n",
        "#     {\n",
        "#         \"id\": 1,\n",
        "#         \"key\": \"69629e2241ca3f96a3e97587ad5072e5\",\n",
        "#         \"description\": \"eqdlaec669@fugmi.com\",\n",
        "#         \"remaining_characters\": 376\n",
        "#     },\n",
        "#     {\n",
        "#         \"id\": 2,\n",
        "#         \"key\": \"96028d102d0734fd815519ead6c6a625\",\n",
        "#         \"description\": \"mateuszmroz001@gmail.com\",\n",
        "#         \"remaining_characters\": 4859\n",
        "#     },\n",
        "#     {\n",
        "#         \"id\": 3,\n",
        "#         \"key\": \"4d88c7168ddf8a163ffbf176276e72c5\",\n",
        "#         \"description\": \"mateuszmrozkun@gmail.com\",\n",
        "#         \"remaining_characters\": 10000\n",
        "#     },\n",
        "#     {\n",
        "#         \"id\": 4,\n",
        "#         \"key\": \"59f3ff34e070b562f8ac4f5847bf5f77\",\n",
        "#         \"description\": \"tojestpoprostutest@gmail.com\",\n",
        "#         \"remaining_characters\": 10000\n",
        "#     }\n",
        "# ]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Rtizm2-8A14z"
      },
      "outputs": [],
      "source": [
        "# @title ElevenLabs Infinite TTS API - Anime Lektor PL #1 bez asynchroniczności wolniejsze { run: \"auto\" }\n",
        "import pysrt\n",
        "from pydub import AudioSegment\n",
        "import os\n",
        "import glob\n",
        "from google.colab import files\n",
        "import ipywidgets as widgets\n",
        "import requests\n",
        "from IPython.display import display, HTML\n",
        "import shutil\n",
        "\n",
        "#===============================================================================\n",
        "# Button CSS\n",
        "display(HTML('''\n",
        "<style>\n",
        "    .widget-button {\n",
        "        font-weight: bold !important;\n",
        "    }\n",
        "    .widget-button.jupyter-widgets.widget-button.mod-active,\n",
        "    .widget-button:active {\n",
        "        background-color: #2d2e2e;\n",
        "    }\n",
        "    .widget-toggle-button {\n",
        "        font-weight: bold !important;\n",
        "    }\n",
        "    .widget-toggle-button.jupyter-widgets.widget-toggle-button.mod-active,\n",
        "    .widget-toggle-button:active {\n",
        "        background-color: #2d2e2e;\n",
        "    }\n",
        "</style>\n",
        "'''))\n",
        "#===============================================================================\n",
        "\n",
        "os.chdir('/content/')\n",
        "\n",
        "class AudioGenerator:\n",
        "    def __init__(self, input_folder='input', output_folder='audio_output'):\n",
        "        self.api_keys = []\n",
        "        self.api_key_statuses = {key: True for key in self.api_keys}\n",
        "        self.audio_cache = {}\n",
        "        self.use_cache = False  # Przełącznik cache'a\n",
        "\n",
        "        self.input_folder = input_folder\n",
        "        self.output_folder = output_folder\n",
        "\n",
        "        os.makedirs(input_folder, exist_ok=True)\n",
        "        os.makedirs(output_folder, exist_ok=True)\n",
        "\n",
        "    def update_api_keys(self, api_keys):\n",
        "        self.api_keys = [key['key'] for key in api_keys]\n",
        "        self.api_key_statuses = {key['key']: True for key in api_keys}\n",
        "\n",
        "    def generate_audio(self, text, index, api_key, temp_folder):\n",
        "        CHUNK_SIZE = 1024\n",
        "        url = \"https://api.elevenlabs.io/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL\" # Bella 0.5 0.75 | Stabilny Najlepszy\n",
        "        # url = \"https://api.elevenlabs.io/v1/text-to-speech/ExUL9WhYaSyp0aHiA3TU\" # Scarlett - 💯% seductive 🔥 0.5 0.5 | Niestabilny\n",
        "        # url = \"https://api.elevenlabs.io/v1/text-to-speech/JoeAjOpsgvMdLp28p97A\" # Brian - Slow speaking and deep 0.5 0.75 | Bardzo Stabilny\n",
        "        # url = \"https://api.elevenlabs.io/v1/text-to-speech/XgjAPAgn6XVf0WYFCReM\" # Knightley - dapper and deep narrator 0.5 0.75 | Lekko Niestabilny\n",
        "        # url = \"https://api.elevenlabs.io/v1/text-to-speech/Vms109RQ0LiOrqV6Ktn9\" # Joanne - pensive, introspective, soft and lovely  0.5 0.75 | Stabilny Monotonny\n",
        "        # url = \"https://api.elevenlabs.io/v1/text-to-speech/piTKgcLEGmPE4e6mEKli\" # Nicole - szpt 0.5 0.75 | Lekko Niestabilny\n",
        "\n",
        "        headers = {\n",
        "            \"Accept\": \"audio/mpeg\",\n",
        "            \"Content-Type\": \"application/json\",\n",
        "            \"xi-api-key\": api_key\n",
        "        }\n",
        "        data = {\n",
        "            \"text\": text,\n",
        "            \"model_id\": \"eleven_multilingual_v2\",\n",
        "            \"voice_settings\": {\n",
        "                \"stability\": 0.5,\n",
        "                \"similarity_boost\": 0.75\n",
        "            }\n",
        "        }\n",
        "\n",
        "        audio_file_path = f'{temp_folder}/{index}.mp3'\n",
        "\n",
        "        if self.use_cache and text in self.audio_cache:\n",
        "            return self.audio_cache[text], True\n",
        "\n",
        "        response = requests.post(url, json=data, headers=headers)\n",
        "        if response.status_code == 200:\n",
        "            with open(audio_file_path, 'wb') as f:\n",
        "                for chunk in response.iter_content(chunk_size=CHUNK_SIZE):\n",
        "                    if chunk:\n",
        "                        f.write(chunk)\n",
        "            self.audio_cache[text] = audio_file_path\n",
        "            return audio_file_path, False\n",
        "        else:\n",
        "            self.api_key_statuses[api_key] = False\n",
        "            return None, False\n",
        "\n",
        "    def process_file(self, filename):\n",
        "        base_filename = os.path.basename(filename)\n",
        "        temp_folder = f'tmp_output_{base_filename}'\n",
        "        os.makedirs(temp_folder, exist_ok=True)\n",
        "\n",
        "        subs = self.load_srt_file(filename)\n",
        "        self.print_subtitles(subs, temp_folder)\n",
        "        self.convert_audio_files(subs, temp_folder)\n",
        "        self.combine_audio(subs, filename, temp_folder)\n",
        "\n",
        "    def print_subtitles(self, subs, temp_folder):\n",
        "        total_char_count = 0\n",
        "        for index, sub in enumerate(subs, start=1):\n",
        "            char_count = len(sub.text)\n",
        "            for api_key in self.api_keys:\n",
        "                if self.api_key_statuses[api_key]:\n",
        "                    audio_file_path, from_cache = self.generate_audio(sub.text, index, api_key, temp_folder)\n",
        "                    if audio_file_path:\n",
        "                        new_audio_file_path = f'{temp_folder}/{index}.mp3'\n",
        "                        if audio_file_path != new_audio_file_path:\n",
        "                            shutil.copy(audio_file_path, new_audio_file_path)\n",
        "                        if from_cache:\n",
        "                            print(f\"{index}. {sub.text} RC: 0\")\n",
        "                        else:\n",
        "                            total_char_count += char_count\n",
        "                            print(f\"{index}. {sub.text} RC: {char_count}\")\n",
        "                        break\n",
        "            else:\n",
        "                print(\"Wszystkie klucze API są wyczerpane. Proszę dodać więcej kluczy.\")\n",
        "\n",
        "        print(f\"Łączna liczba znaków: {total_char_count}\")\n",
        "\n",
        "    def load_srt_file(self, filename):\n",
        "        return pysrt.open(filename, encoding='utf-8')\n",
        "\n",
        "    def convert_audio_files(self, subs, temp_folder):\n",
        "        for index, _ in enumerate(subs, start=1):\n",
        "            audio_file = f'{temp_folder}/{index}.mp3'\n",
        "            audio = AudioSegment.from_mp3(audio_file)\n",
        "            audio.export(audio_file.replace('.mp3', '.wav'), format='wav')\n",
        "\n",
        "    def combine_audio(self, subs, filename, temp_folder):\n",
        "        combined = AudioSegment.silent(duration=0)\n",
        "\n",
        "        for index, sub in enumerate(subs, start=1):\n",
        "            start_time = sub.start.ordinal\n",
        "            silence = AudioSegment.silent(duration=start_time - len(combined))\n",
        "            combined += silence\n",
        "\n",
        "            audio_file = f'{temp_folder}/{index}.wav'\n",
        "            audio = AudioSegment.from_wav(audio_file)\n",
        "\n",
        "            combined += audio\n",
        "\n",
        "        output_filename = os.path.basename(filename).replace('.srt', '.eac3')\n",
        "        combined.export(\n",
        "            f\"{self.output_folder}/{output_filename}\", format='wav')\n",
        "        os.system(\n",
        "            f\"ffmpeg -i {self.output_folder}/{output_filename} -c:a {self.output_folder}/{output_filename}\")\n",
        "\n",
        "    def process_all_files(self):\n",
        "        for filename in glob.glob(f'{self.input_folder}/*.srt'):\n",
        "            self.process_file(filename)\n",
        "\n",
        "    def download_files(self):\n",
        "        download_button = widgets.Button(\n",
        "            description='Pobierz Pliki',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        download_button.on_click(self.download_files_callback)\n",
        "        display(download_button)\n",
        "\n",
        "    def download_files_callback(self, b):\n",
        "        for filename in glob.glob(f'{self.output_folder}/*.eac3'):\n",
        "            files.download(filename)\n",
        "\n",
        "    def start_processing(self):\n",
        "        cache_button = widgets.ToggleButton(\n",
        "            value=self.use_cache,\n",
        "            description='Użyj Cache - Zaoszczędź RC',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        cache_button.observe(self.update_cache_status, names='value')\n",
        "        display(cache_button)\n",
        "\n",
        "        start_button = widgets.Button(\n",
        "            description='Wygeneruj Audio',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        start_button.on_click(self.start_processing_callback)\n",
        "        display(start_button)\n",
        "\n",
        "    def update_cache_status(self, change):\n",
        "        self.use_cache = change['new']\n",
        "\n",
        "    @execution_timer\n",
        "    def start_processing_callback(self, b):\n",
        "        self.process_all_files()\n",
        "        self.download_files()\n",
        "\n",
        "def main():\n",
        "    display(HTML('<h1>ElevenLabs Infinite TTS API - Anime Lektor PL</h1>'))\n",
        "    audio_generator = AudioGenerator()\n",
        "    audio_generator.update_api_keys(api_keys)\n",
        "    audio_generator.start_processing()\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Ugdq5rYPDcvl"
      },
      "outputs": [],
      "source": [
        "# @title ElevenLabs Infinite TTS API - TEST asynchroniczności #1 { run: \"auto\" }\n",
        "import os\n",
        "import pysrt\n",
        "import requests\n",
        "import asyncio\n",
        "from pydub import AudioSegment\n",
        "\n",
        "# Wczytaj plik .srt i podziel go na części\n",
        "\n",
        "\n",
        "def load_srt(file_path):\n",
        "    return pysrt.open(file_path, encoding='utf-8')\n",
        "\n",
        "# Wygeneruj asynchronicznie audio za pomocą API ElevenLabs\n",
        "async def generate_audio(subtitle, api_key):\n",
        "    url = \"https://api.elevenlabs.io/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL\"\n",
        "    headers = {\n",
        "        \"Accept\": \"audio/mpeg\",\n",
        "        \"Content-Type\": \"application/json\",\n",
        "        \"xi-api-key\": api_key\n",
        "    }\n",
        "    data = {\n",
        "        \"text\": subtitle.text,\n",
        "        \"model_id\": \"eleven_multilingual_v2\",\n",
        "        \"voice_settings\": {\n",
        "            \"stability\": 0.5,\n",
        "            \"similarity_boost\": 0.75\n",
        "        }\n",
        "    }\n",
        "    response = requests.post(url, json=data, headers=headers)\n",
        "    with open(f'{subtitle.index}.wav', 'wb') as f:\n",
        "        f.write(response.content)\n",
        "\n",
        "# Połącz pliki audio w jeden duży plik audio\n",
        "def merge_audio_files(subtitles):\n",
        "    audio_files = [f\"{subtitle.index}.wav\" for subtitle in subtitles]\n",
        "    combined_audio = AudioSegment.empty()\n",
        "    for file in sorted(audio_files, key=lambda x: int(x.split('.')[0])):\n",
        "        combined_audio += AudioSegment.from_wav(file)\n",
        "    combined_audio.export(\"output.wav\", format=\"wav\")\n",
        "\n",
        "# Główna funkcja\n",
        "async def main():\n",
        "    subtitles = load_srt('1.srt')\n",
        "    api_keys = ['4d88c7168ddf8a163ffbf176276e72c5', '59f3ff34e070b562f8ac4f5847bf5f77']  # Lista kluczy API\n",
        "    for subtitle in subtitles:\n",
        "        for api_key in api_keys:\n",
        "            await generate_audio(subtitle, api_key)\n",
        "    merge_audio_files(subtitles)\n",
        "\n",
        "# Uruchom główną funkcję\n",
        "if __name__ == \"__main__\":\n",
        "    asyncio.run(main())\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "2vafcq6yBJI0"
      },
      "outputs": [],
      "source": [
        "# @title ElevenLabs Infinite TTS API - TEST asynchroniczności #2 - API 2 rządania na raz, i będzie ok { run: \"auto\" }\n",
        "import requests\n",
        "import asyncio\n",
        "import aiohttp\n",
        "import time\n",
        "import nest_asyncio\n",
        "\n",
        "nest_asyncio.apply()  # Zastosowanie nest_asyncio\n",
        "\n",
        "CHUNK_SIZE = 1024\n",
        "url = \"https://api.elevenlabs.io/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL\"\n",
        "\n",
        "headers = {\n",
        "  \"Accept\": \"audio/mpeg\",\n",
        "  \"Content-Type\": \"application/json\",\n",
        "  \"xi-api-key\": \"8cea86b1109cd17fc38abdc5e773f19f\"\n",
        "}\n",
        "\n",
        "# Lista rzeczy do powiedzenia\n",
        "texts = [\"Witaj świecie, jak się masz?\",\n",
        "         \"To jest drugie zdanie.\",\n",
        "         \"To jest trzecie zdanie.\"]\n",
        "\n",
        "semaphore = asyncio.Semaphore(2)  # Utworzenie semafora z limitem 2\n",
        "\n",
        "async def download_file(session, url, headers, data, file_name):\n",
        "    async with semaphore, session.post(url, json=data, headers=headers) as response:\n",
        "        if response.status != 200:\n",
        "            raise Exception(f\"Request to {url} returned status code {response.status}\")\n",
        "        with open(file_name, 'wb') as f:\n",
        "            while True:\n",
        "                chunk = await response.content.read(CHUNK_SIZE)\n",
        "                if not chunk:\n",
        "                    break\n",
        "                f.write(chunk)\n",
        "\n",
        "async def main():\n",
        "    async with aiohttp.ClientSession() as session:\n",
        "        tasks = []\n",
        "        for i, text in enumerate(texts, start=1):\n",
        "            data = {\n",
        "                \"text\": text,\n",
        "                \"model_id\": \"eleven_multilingual_v2\",\n",
        "                \"voice_settings\": {\n",
        "                    \"stability\": 0.5,\n",
        "                    \"similarity_boost\": 0.75\n",
        "                }\n",
        "            }\n",
        "            file_name = f'{i}.mp3'\n",
        "            tasks.append(download_file(session, url, headers, data, file_name))\n",
        "        await asyncio.gather(*tasks)\n",
        "\n",
        "start_time = time.time()\n",
        "await main()\n",
        "end_time = time.time()\n",
        "print(\"Zakończono wszystkie akcje. Czas wykonania: \", end_time - start_time, \"sekund.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Ebk75lMEB4Fq"
      },
      "outputs": [],
      "source": [
        "# @title ElevenLabs Infinite TTS API - TEST asynchroniczności #3 - Generowanie dla kilku kluczów api naraz błędy z api może mieć tylko 2 rządania na raz i pomoja tekst nwm jak to naprawić możliwość bycia szybkim, ale dużeo błędów do naprawienia { run: \"auto\" }\n",
        "\n",
        "import pysrt\n",
        "from pydub import AudioSegment\n",
        "import os\n",
        "import glob\n",
        "import shutil\n",
        "import nest_asyncio\n",
        "import aiohttp\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import display, HTML\n",
        "from google.colab import files\n",
        "import asyncio\n",
        "import random\n",
        "\n",
        "# Inicjalizacja nest_asyncio\n",
        "nest_asyncio.apply()\n",
        "\n",
        "# Tworzenie klasy AudioGenerator\n",
        "class AudioGenerator:\n",
        "    def __init__(self, input_folder='input', output_folder='audio_output'):\n",
        "        self.api_keys = []\n",
        "        self.api_key_statuses = {key: True for key in self.api_keys}\n",
        "        self.audio_cache = {}\n",
        "        self.use_cache = False\n",
        "\n",
        "        self.input_folder = input_folder\n",
        "        self.output_folder = output_folder\n",
        "\n",
        "        os.makedirs(input_folder, exist_ok=True)\n",
        "        os.makedirs(output_folder, exist_ok=True)\n",
        "\n",
        "    def update_api_keys(self, api_keys):\n",
        "        self.api_keys = [key['key'] for key in api_keys]\n",
        "        self.api_key_statuses = {key['key']: True for key in api_keys}\n",
        "\n",
        "    async def generate_audio(self, text, index, temp_folder, char_count):\n",
        "        CHUNK_SIZE = 1024\n",
        "        random.shuffle(self.api_keys)\n",
        "\n",
        "        for api_key in self.api_keys:\n",
        "            if self.api_key_statuses[api_key]:\n",
        "                url = \"https://api.elevenlabs.io/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL\" # Bella 0.5 0.75 | Stabilny Najlepszy\n",
        "                headers = self.create_headers(api_key)\n",
        "                data = self.create_data(text)\n",
        "\n",
        "                audio_file_path = f'{temp_folder}/{index}.mp3'\n",
        "\n",
        "                if self.use_cache and text in self.audio_cache:\n",
        "                    return self.audio_cache[text], True, api_key\n",
        "\n",
        "                async with aiohttp.ClientSession() as session:\n",
        "                    async with session.post(url, json=data, headers=headers) as response:\n",
        "                        if response.status == 200:\n",
        "                            await self.write_audio_file(response, audio_file_path, CHUNK_SIZE)\n",
        "                            self.audio_cache[text] = audio_file_path\n",
        "                            return audio_file_path, False, api_key\n",
        "                        else:\n",
        "                            self.api_key_statuses[api_key] = False\n",
        "\n",
        "        return None, False, None\n",
        "\n",
        "    def create_headers(self, api_key):\n",
        "        return {\n",
        "            \"Accept\": \"audio/mpeg\",\n",
        "            \"Content-Type\": \"application/json\",\n",
        "            \"xi-api-key\": api_key\n",
        "        }\n",
        "\n",
        "    def create_data(self, text):\n",
        "        return {\n",
        "            \"text\": text,\n",
        "            \"model_id\": \"eleven_multilingual_v2\",\n",
        "            \"voice_settings\": {\n",
        "                \"stability\": 0.5,\n",
        "                \"similarity_boost\": 0.75\n",
        "            }\n",
        "        }\n",
        "\n",
        "    async def write_audio_file(self, response, audio_file_path, CHUNK_SIZE):\n",
        "        with open(audio_file_path, 'wb') as f:\n",
        "            while True:\n",
        "                chunk = await response.content.read(CHUNK_SIZE)\n",
        "                if not chunk:\n",
        "                    break\n",
        "                f.write(chunk)\n",
        "\n",
        "    async def process_file(self, filename):\n",
        "        base_filename = os.path.basename(filename)\n",
        "        temp_folder = self.create_temp_folder(base_filename)\n",
        "\n",
        "        subs = self.load_srt_file(filename)\n",
        "        await self.process_subtitles(subs, temp_folder)\n",
        "        self.convert_audio_files(subs, temp_folder)\n",
        "        self.combine_audio(subs, filename, temp_folder)\n",
        "\n",
        "    def create_temp_folder(self, base_filename):\n",
        "        temp_folder = f'tmp_output_{base_filename}'\n",
        "        os.makedirs(temp_folder, exist_ok=True)\n",
        "        return temp_folder\n",
        "\n",
        "    async def process_subtitles(self, subs, temp_folder):\n",
        "        total_char_count = 0\n",
        "        for index, sub in enumerate(subs, start=1):\n",
        "            char_count = len(sub.text)\n",
        "            for api_key in self.api_keys:\n",
        "                if self.api_key_statuses[api_key]:\n",
        "                    audio_file_path, from_cache = await self.generate_audio(sub.text, index, api_key, temp_folder)\n",
        "                    if audio_file_path:\n",
        "                        new_audio_file_path = self.copy_audio_file(audio_file_path, temp_folder, index)\n",
        "                        self.print_subtitle_info(index, sub.text, char_count, from_cache)\n",
        "                        total_char_count += char_count if not from_cache else 0\n",
        "                        break\n",
        "            else:\n",
        "                print(\"Wszystkie klucze API są wyczerpane. Proszę dodać więcej kluczy.\")\n",
        "        print(f\"Łączna liczba znaków: {total_char_count}\")\n",
        "\n",
        "    async def process_subtitle(self, sub, index, temp_folder, char_count, semaphore):\n",
        "        total_char_count = 0\n",
        "        async with semaphore:\n",
        "            audio_file_path, from_cache, api_key = await self.generate_audio(sub.text, index, temp_folder, char_count)\n",
        "            if audio_file_path:\n",
        "                new_audio_file_path = self.copy_audio_file(audio_file_path, temp_folder, index)\n",
        "                self.print_subtitle_info(index, sub.text, char_count, from_cache, api_key)\n",
        "                if not from_cache:\n",
        "                    total_char_count += char_count\n",
        "                return total_char_count\n",
        "\n",
        "    def copy_audio_file(self, audio_file_path, temp_folder, index):\n",
        "        new_audio_file_path = f'{temp_folder}/{index}.mp3'\n",
        "        if audio_file_path != new_audio_file_path:\n",
        "            shutil.copy(audio_file_path, new_audio_file_path)\n",
        "        return new_audio_file_path\n",
        "\n",
        "    def print_subtitle_info(self, index, text, char_count, from_cache, api_key):\n",
        "        print(f\"{index}. Napis: {text} | Liczba RC: {char_count if not from_cache else 0} | ID Klucza API: {api_key}\")\n",
        "\n",
        "    def load_srt_file(self, filename):\n",
        "        return pysrt.open(filename, encoding='utf-8')\n",
        "\n",
        "    def convert_audio_files(self, subs, temp_folder):\n",
        "        for index, _ in enumerate(subs, start=1):\n",
        "            audio_file = f'{temp_folder}/{index}.mp3'\n",
        "            audio = AudioSegment.from_mp3(audio_file)\n",
        "            audio.export(audio_file.replace('.mp3', '.wav'), format='wav')\n",
        "\n",
        "    def combine_audio(self, subs, filename, temp_folder):\n",
        "        combined = AudioSegment.silent(duration=0)\n",
        "\n",
        "        for index, sub in enumerate(subs, start=1):\n",
        "            start_time = sub.start.ordinal\n",
        "            silence = AudioSegment.silent(duration=start_time - len(combined))\n",
        "            combined += silence\n",
        "\n",
        "            audio_file = f'{temp_folder}/{index}.wav'\n",
        "            audio = AudioSegment.from_wav(audio_file)\n",
        "\n",
        "            combined += audio\n",
        "\n",
        "        output_filename = os.path.basename(filename).replace('.srt', '.eac3')\n",
        "        combined.export(\n",
        "            f\"{self.output_folder}/{output_filename}\", format='wav')\n",
        "        os.system(\n",
        "            f\"ffmpeg -i {self.output_folder}/{output_filename} -c:a {self.output_folder}/{output_filename}\")\n",
        "\n",
        "    async def process_all_files(self):\n",
        "        for filename in glob.glob(f'{self.input_folder}/*.srt'):\n",
        "            await self.process_file(filename)\n",
        "\n",
        "    def download_files(self):\n",
        "        download_button = self.create_download_button()\n",
        "        display(download_button)\n",
        "\n",
        "    def create_download_button(self):\n",
        "        download_button = widgets.Button(\n",
        "            description='Pobierz Pliki',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        download_button.on_click(self.download_files_callback)\n",
        "        return download_button\n",
        "\n",
        "    def download_files_callback(self, b):\n",
        "        for filename in glob.glob(f'{self.output_folder}/*.eac3'):\n",
        "            files.download(filename)\n",
        "\n",
        "    def start_processing(self):\n",
        "        cache_button = self.create_cache_button()\n",
        "        display(cache_button)\n",
        "\n",
        "        start_button = self.create_start_button()\n",
        "        display(start_button)\n",
        "\n",
        "    def create_cache_button(self):\n",
        "        cache_button = widgets.ToggleButton(\n",
        "            value=self.use_cache,\n",
        "            description='Użyj Cache - Zaoszczędź RC',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        cache_button.observe(self.update_cache_status, names='value')\n",
        "        return cache_button\n",
        "\n",
        "    def create_start_button(self):\n",
        "        start_button = widgets.Button(\n",
        "            description='Wygeneruj Audio',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        start_button.on_click(self.start_processing_callback)\n",
        "        return start_button\n",
        "\n",
        "    def update_cache_status(self, change):\n",
        "        self.use_cache = change['new']\n",
        "\n",
        "    def start_processing_callback(self, b):\n",
        "        loop = asyncio.get_event_loop()\n",
        "        loop.run_until_complete(self.process_all_files())\n",
        "        self.download_files()\n",
        "\n",
        "\n",
        "# Główna funkcja\n",
        "def main():\n",
        "    display(HTML('<h1>ElevenLabs Infinite TTS API - Anime Lektor PL</h1>'))\n",
        "    audio_generator = AudioGenerator()\n",
        "    audio_generator.update_api_keys(api_keys)\n",
        "    audio_generator.start_processing()\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Bh27QpvwsL_Z"
      },
      "outputs": [],
      "source": [
        "# @title ElevenLabs Infinite TTS API - Anime Lektor PL (asyncio) { run: \"auto\" }\n",
        "import os\n",
        "import shutil\n",
        "import glob\n",
        "import asyncio\n",
        "import nest_asyncio\n",
        "import aiohttp\n",
        "import pysrt\n",
        "from pydub import AudioSegment\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import display, HTML\n",
        "from google.colab import files\n",
        "from elevenlabs import voices as el_voices\n",
        "from elevenlabs import set_api_key\n",
        "\n",
        "#===============================================================================\n",
        "# Button CSS\n",
        "display(HTML('''\n",
        "<style>\n",
        "    .widget-button {\n",
        "        font-weight: bold !important;\n",
        "    }\n",
        "    .widget-button.jupyter-widgets.widget-button.mod-active,\n",
        "    .widget-button:active {\n",
        "        background-color: #2d2e2e;\n",
        "    }\n",
        "    .widget-toggle-button {\n",
        "        font-weight: bold !important;\n",
        "    }\n",
        "    .widget-toggle-button.jupyter-widgets.widget-toggle-button.mod-active,\n",
        "    .widget-toggle-button:active {\n",
        "        background-color: #2d2e2e;\n",
        "    }\n",
        "</style>\n",
        "'''))\n",
        "#===============================================================================\n",
        "\n",
        "os.chdir('/content/')\n",
        "nest_asyncio.apply()\n",
        "\n",
        "class AudioGenerator:\n",
        "    def __init__(self, input_folder='input', output_folder='audio_output'):\n",
        "        self.api_keys = []\n",
        "        self.api_key_statuses = {key: True for key in self.api_keys}\n",
        "        self.audio_cache = {}\n",
        "        self.use_cache = False\n",
        "\n",
        "        self.input_folder = input_folder\n",
        "        self.output_folder = output_folder\n",
        "\n",
        "        os.makedirs(input_folder, exist_ok=True)\n",
        "        os.makedirs(output_folder, exist_ok=True)\n",
        "\n",
        "        self.voice_names = {\n",
        "            'Brian': ['Brian', 'Brian - Slow speaking and deep'],\n",
        "            'Bella': ['Bella'],\n",
        "            'Scarlett': ['Scarlett'],\n",
        "            'Knightley': ['Knightley'],\n",
        "            'Joanne': ['Joanne'],\n",
        "            'Nicole': ['Nicole']\n",
        "        }\n",
        "\n",
        "        self.voice_dropdown = widgets.Dropdown(options=list(self.voice_names.keys()))\n",
        "        display(self.voice_dropdown)\n",
        "\n",
        "    def update_api_keys(self, api_keys):\n",
        "        self.api_keys = [key['key'] for key in api_keys]\n",
        "        self.api_key_statuses = {key['key']: True for key in api_keys}\n",
        "\n",
        "    def create_headers(self, api_key):\n",
        "        return {\n",
        "            \"Accept\": \"audio/mpeg\",\n",
        "            \"Content-Type\": \"application/json\",\n",
        "            \"xi-api-key\": api_key\n",
        "        }\n",
        "\n",
        "    def create_data(self, text):\n",
        "        return {\n",
        "            \"text\": text,\n",
        "            \"model_id\": \"eleven_multilingual_v2\",\n",
        "            \"voice_settings\": {\n",
        "                \"stability\": 0.5,\n",
        "                \"similarity_boost\": 0.75\n",
        "            }\n",
        "        }\n",
        "\n",
        "    def find_voice_id(self, voice_list, voice_names):\n",
        "        for voice in voice_list.voices:\n",
        "            if voice.name in voice_names:\n",
        "                return voice.voice_id\n",
        "        return None\n",
        "\n",
        "    async def generate_audio_url(self, api_key):\n",
        "        set_api_key(api_key)\n",
        "        voice_list = voices()\n",
        "        voice_id = self.find_voice_id(voice_list, self.voice_names[self.voice_dropdown.value])\n",
        "        if voice_id:\n",
        "            return f\"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}\"\n",
        "        else:\n",
        "            return None\n",
        "\n",
        "    async def write_audio_file(self, response, audio_file_path, CHUNK_SIZE):\n",
        "        with open(audio_file_path, 'wb') as f:\n",
        "            while True:\n",
        "                chunk = await response.content.read(CHUNK_SIZE)\n",
        "                if not chunk:\n",
        "                    break\n",
        "                f.write(chunk)\n",
        "\n",
        "    async def generate_audio(self, text, index, api_key, temp_folder):\n",
        "        CHUNK_SIZE = 1024\n",
        "        url = await self.generate_audio_url(api_key)\n",
        "        if url is None:\n",
        "            print(f\"Nie znaleziono głosu dla klucza API: {api_key}\")\n",
        "            return None, False\n",
        "        headers = self.create_headers(api_key)\n",
        "        data = self.create_data(text)\n",
        "\n",
        "        audio_file_path = f'{temp_folder}/{index}.mp3'\n",
        "\n",
        "        if self.use_cache and text in self.audio_cache:\n",
        "            return self.audio_cache[text], True\n",
        "\n",
        "        async with aiohttp.ClientSession() as session:\n",
        "            async with session.post(url, json=data, headers=headers) as response:\n",
        "                if response.status == 200:\n",
        "                    await self.write_audio_file(response, audio_file_path, CHUNK_SIZE)\n",
        "                    self.audio_cache[text] = audio_file_path\n",
        "                    return audio_file_path, False\n",
        "                else:\n",
        "                    self.api_key_statuses[api_key] = False\n",
        "                    return None, False\n",
        "\n",
        "    def copy_audio_file(self, audio_file_path, temp_folder, index):\n",
        "        new_audio_file_path = f'{temp_folder}/{index}.mp3'\n",
        "        if audio_file_path != new_audio_file_path:\n",
        "            shutil.copy(audio_file_path, new_audio_file_path)\n",
        "        return new_audio_file_path\n",
        "\n",
        "    def print_subtitle_info(self, index, text, char_count, from_cache):\n",
        "        print(f\"{index}. {text} RC: {char_count if not from_cache else 0}\")\n",
        "\n",
        "    def load_srt_file(self, filename):\n",
        "        return pysrt.open(filename, encoding='utf-8')\n",
        "\n",
        "    def convert_audio_files(self, subs, temp_folder):\n",
        "        for index, _ in enumerate(subs, start=1):\n",
        "            audio_file = f'{temp_folder}/{index}.mp3'\n",
        "            audio = AudioSegment.from_mp3(audio_file)\n",
        "            audio.export(audio_file.replace('.mp3', '.wav'), format='wav')\n",
        "\n",
        "    def combine_audio(self, subs, filename, temp_folder):\n",
        "        combined = AudioSegment.silent(duration=0)\n",
        "\n",
        "        for index, sub in enumerate(subs, start=1):\n",
        "            start_time = sub.start.ordinal\n",
        "            silence = AudioSegment.silent(duration=start_time - len(combined))\n",
        "            combined += silence\n",
        "\n",
        "            audio_file = f'{temp_folder}/{index}.wav'\n",
        "            audio = AudioSegment.from_wav(audio_file)\n",
        "\n",
        "            combined += audio\n",
        "\n",
        "        output_filename = os.path.basename(filename).replace('.srt', '.eac3')\n",
        "        combined.export(\n",
        "            f\"{self.output_folder}/{output_filename}\", format='wav')\n",
        "        os.system(\n",
        "            f\"ffmpeg -i {self.output_folder}/{output_filename} -c:a {self.output_folder}/{output_filename}\")\n",
        "\n",
        "    async def process_file(self, filename):\n",
        "        print(f\"Przetwarzanie pliku: {filename}\")\n",
        "        base_filename = os.path.basename(filename)\n",
        "        temp_folder = self.create_temp_folder(base_filename)\n",
        "\n",
        "        subs = self.load_srt_file(filename)\n",
        "        await self.process_subtitles(subs, temp_folder)\n",
        "        self.convert_audio_files(subs, temp_folder)\n",
        "        self.combine_audio(subs, filename, temp_folder)\n",
        "        print(f\"Przetworzono plik: {filename}\")\n",
        "\n",
        "    def create_temp_folder(self, base_filename):\n",
        "        temp_folder = f'tmp_output_{base_filename}'\n",
        "        os.makedirs(temp_folder, exist_ok=True)\n",
        "        return temp_folder\n",
        "\n",
        "    async def process_subtitles(self, subs, temp_folder):\n",
        "        total_char_count = 0\n",
        "        for index, sub in enumerate(subs, start=1):\n",
        "            char_count = len(sub.text)\n",
        "            for api_key in self.api_keys:\n",
        "                if self.api_key_statuses[api_key]:\n",
        "                    audio_file_path, from_cache = await self.generate_audio(sub.text, index, api_key, temp_folder)\n",
        "                    if audio_file_path:\n",
        "                        new_audio_file_path = self.copy_audio_file(audio_file_path, temp_folder, index)\n",
        "                        self.print_subtitle_info(index, sub.text, char_count, from_cache)\n",
        "                        total_char_count += char_count if not from_cache else 0\n",
        "                        break\n",
        "            else:\n",
        "                print(\"Wszystkie klucze API są wyczerpane. Proszę dodać więcej kluczy.\")\n",
        "        print(f\"Łączna liczba znaków: {total_char_count}\")\n",
        "\n",
        "    async def process_all_files(self):\n",
        "        for filename in glob.glob(f'{self.input_folder}/*.srt'):\n",
        "            await self.process_file(filename)\n",
        "\n",
        "    def download_files(self):\n",
        "        download_button = self.create_download_button()\n",
        "        display(download_button)\n",
        "\n",
        "    def create_download_button(self):\n",
        "        download_button = widgets.Button(\n",
        "            description='Pobierz Pliki',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        download_button.on_click(self.download_files_callback)\n",
        "        return download_button\n",
        "\n",
        "    def download_files_callback(self, b):\n",
        "        for filename in glob.glob(f'{self.output_folder}/*.eac3'):\n",
        "            files.download(filename)\n",
        "\n",
        "    def start_processing(self):\n",
        "        cache_button = self.create_cache_button()\n",
        "        display(cache_button)\n",
        "\n",
        "        start_button = self.create_start_button()\n",
        "        display(start_button)\n",
        "\n",
        "    def create_cache_button(self):\n",
        "        cache_button = widgets.ToggleButton(\n",
        "            value=self.use_cache,\n",
        "            description='Użyj Cache - Zaoszczędź RC',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        cache_button.observe(self.update_cache_status, names='value')\n",
        "        return cache_button\n",
        "\n",
        "    def create_start_button(self):\n",
        "        start_button = widgets.Button(\n",
        "            description='Wygeneruj Audio',\n",
        "            style=dict(font_weight='bold'),\n",
        "            layout=widgets.Layout(width='300px', height='30px')\n",
        "        )\n",
        "        start_button.on_click(self.start_processing_callback)\n",
        "        return start_button\n",
        "\n",
        "    def update_cache_status(self, change):\n",
        "        self.use_cache = change['new']\n",
        "\n",
        "    @execution_timer\n",
        "    def start_processing_callback(self, b):\n",
        "        loop = asyncio.get_event_loop()\n",
        "        loop.run_until_complete(self.process_all_files())\n",
        "        self.download_files()\n",
        "\n",
        "def main():\n",
        "    display(HTML('<h1>ElevenLabs Infinite TTS API - Anime Lektor PL</h1>'))\n",
        "    audio_generator = AudioGenerator()\n",
        "    audio_generator.update_api_keys(api_keys)\n",
        "    audio_generator.start_processing()\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "AmgP429xEOV9",
        "BG2fu7anM5kx",
        "rXlgAmbNM5kx",
        "aqkvCKDTECt8",
        "_3XchGpZM5kz",
        "oQJVtDCuM5ky",
        "FGP5SNBFeHVm",
        "ktxyJ-PxG-ue"
      ],
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.10.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}