RunAudioMakerTelegramBot.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPxwwTd01BqsGx7JA2jQ9gC",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mehdihoore/TTS_TELEGRAM_BOT_WithFilesStopUser/blob/main/RunAudioMakerTelegramBot.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Instructions to Run the Telegram Bot in Colab\n",
        "\n",
        "1. **Step 1: Install Required Modules**\n",
        "   - Run the first code cell that installs the necessary modules by pasting and running this command:\n",
        "     ```python\n",
        "     !pip install telethon edge-tts pydub psutil python-docx pymupdf\n",
        "     ```\n",
        "   - This will install all required dependencies to operate the bot.\n",
        "\n",
        "2. **Step 2: Set Up API Credentials**\n",
        "   - Follow the instructions provided above to obtain your `API_ID`, `API_HASH`, and `BOT_TOKEN` for the Telegram bot.\n",
        "   - Once you have these values, insert them into the bot code cell.\n",
        "\n",
        "3. **Step 3: Run the Bot Code**\n",
        "   - Run the cell containing the bot code.\n",
        "   - This will start the bot, and it will listen for incoming messages or files on Telegram.\n",
        "\n",
        "4. **Using the Bot**\n",
        "   - Open Telegram and send a message or a file to the bot. The bot should respond by processing your request as defined in the code.\n",
        "\n",
        "5. **Stopping the Bot**\n",
        "   - To stop the bot, you can interrupt the Colab cell by clicking **Stop** or pressing **Ctrl + M + I**.\n",
        "\n",
        "---\n",
        "\n",
        "Follow these steps sequentially, and your bot should be up and running in Colab!\n"
      ],
      "metadata": {
        "id": "gSHX6zmxWn4u"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d4SMODpzU6cV"
      },
      "outputs": [],
      "source": [
        "!pip install telethon edge-tts pydub python-docx pymupdf psutil"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Instructions to Get API Credentials for Telegram Bot\n",
        "\n",
        "#### 1. Getting `API_ID` and `API_HASH`\n",
        "   - **Step 1**: Go to [my.telegram.org](https://my.telegram.org/).\n",
        "   - **Step 2**: Log in with your Telegram account.\n",
        "   - **Step 3**: Click on **API Development Tools**.\n",
        "   - **Step 4**: Provide an **App title** (e.g., \"MyTelegramBot\") and a **Short name** (any unique name).\n",
        "   - **Step 5**: After submitting, you’ll see your `API_ID` and `API_HASH`. Copy these values.\n",
        "\n",
        "#### 2. Getting the `BOT_TOKEN`\n",
        "   - **Step 1**: Open the **Telegram app** and start a chat with [BotFather](https://t.me/BotFather).\n",
        "   - **Step 2**: Send the command `/newbot` to BotFather to create a new bot.\n",
        "   - **Step 3**: Provide a name and a username for the bot (username must end in \"bot\", like `MySampleBot`).\n",
        "   - **Step 4**: BotFather will then send a message with the `BOT_TOKEN`. Copy this token.\n",
        "\n",
        "Once you have all three values (`API_ID`, `API_HASH`, and `BOT_TOKEN`), you can add them to the code to authenticate your Telegram bot.\n"
      ],
      "metadata": {
        "id": "3w7MPWp2VVCz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import asyncio\n",
        "import edge_tts\n",
        "import os\n",
        "import time\n",
        "import psutil\n",
        "from pydub import AudioSegment\n",
        "from telethon import TelegramClient, events\n",
        "from telethon.tl.types import DocumentAttributeAudio\n",
        "import fitz  # PyMuPDF for PDFs\n",
        "from docx import Document  # For Word (DOCX)\n",
        "from asyncio import Lock\n",
        "import subprocess\n",
        "from telethon.sessions import StringSession\n",
        "import re\n",
        "\n",
        "# Telegram bot credentials\n",
        "API_ID = \"API_ID\"\n",
        "API_HASH = \"API_HASH\"\n",
        "BOT_TOKEN = \"BOT_TOKEN\"\n",
        "session_file = 'bot_session'\n",
        "# Check if the session file exists and delete it if it does\n",
        "# to avoid OperationalError: database is locked\n",
        "if os.path.exists(session_file):\n",
        "    os.remove(session_file)\n",
        "\n",
        "# Create a new TelegramClient instance\n",
        "client = TelegramClient(StringSession(), API_ID, API_HASH)\n",
        "\n",
        "# Start the client with the bot token\n",
        "await client.start(bot_token=BOT_TOKEN)\n",
        "\n",
        "# State management: store users currently uploading or processing files\n",
        "user_locks = set()\n",
        "file_lock = Lock()\n",
        "\n",
        "def clean_text(text):\n",
        "    \"\"\"Remove URLs from text.\"\"\"\n",
        "    return re.sub(r'http\\S+|www\\S+|https\\S+', '', text, flags=re.MULTILINE).strip()\n",
        "\n",
        "\n",
        "def release_file(filepath):\n",
        "    \"\"\"Release a locked file by terminating the process.\"\"\"\n",
        "    for proc in psutil.process_iter():\n",
        "        try:\n",
        "            for open_file in proc.open_files():\n",
        "                if open_file.path == filepath:\n",
        "                    proc.terminate()\n",
        "                    proc.wait()\n",
        "        except (psutil.NoSuchProcess, psutil.AccessDenied):\n",
        "            pass\n",
        "\n",
        "\n",
        "def validate_and_fix_mp3(file_path):\n",
        "    \"\"\"Check if the MP3 is valid, and fix it if needed.\"\"\"\n",
        "    try:\n",
        "        result = subprocess.run(\n",
        "            ['ffmpeg', '-v', 'error', '-i', file_path, '-f', 'null', '-'],\n",
        "            capture_output=True, text=True\n",
        "        )\n",
        "        if result.returncode != 0:\n",
        "            print(f\"Invalid MP3 detected: {file_path}. Attempting to fix...\")\n",
        "            fixed_path = file_path.replace(\".mp3\", \"_fixed.mp3\")\n",
        "            subprocess.run(['ffmpeg', '-i', file_path,\n",
        "                           '-c', 'copy', fixed_path])\n",
        "            return fixed_path if os.path.exists(fixed_path) else None\n",
        "        return file_path\n",
        "    except Exception as e:\n",
        "        print(f\"Error during MP3 validation: {e}\")\n",
        "        return None\n",
        "\n",
        "\n",
        "def extract_text_from_file(file_path):\n",
        "    \"\"\"Extract text from TXT, PDF, or DOCX files.\"\"\"\n",
        "    ext = os.path.splitext(file_path)[-1].lower()\n",
        "\n",
        "    if ext == '.txt':\n",
        "        with open(file_path, 'r', encoding='utf-8') as f:\n",
        "            return f.read()\n",
        "    elif ext == '.pdf':\n",
        "        text = \"\"\n",
        "        with fitz.open(file_path) as doc:\n",
        "            for page in doc:\n",
        "                text += page.get_text()\n",
        "        return text\n",
        "    elif ext == '.docx':\n",
        "        doc = Document(file_path)\n",
        "        return '\\n'.join([para.text for para in doc.paragraphs])\n",
        "    else:\n",
        "        raise ValueError(\"Unsupported file format\")\n",
        "\n",
        "\n",
        "async def generate_audio_for_paragraph(text, voice, output_filename):\n",
        "    \"\"\"Generate TTS audio for a paragraph.\"\"\"\n",
        "    communicate = edge_tts.Communicate(text, voice)\n",
        "    try:\n",
        "        await communicate.save(output_filename)\n",
        "        print(f\"Generated {output_filename} using {voice}\")\n",
        "        return output_filename\n",
        "    except Exception as e:\n",
        "        print(f\"Error with {voice}: {e}\")\n",
        "        return None\n",
        "\n",
        "\n",
        "async def process_text_to_speech(text, user_id):\n",
        "    \"\"\"Convert text to speech and combine audio files.\"\"\"\n",
        "    voices = [\"fa-IR-FaridNeural\", \"fa-IR-DilaraNeural\"]\n",
        "    paragraphs = [p.strip() for p in text.split('\\n') if p.strip()]\n",
        "\n",
        "    temp_dir = f\"temp_{user_id}_{int(time.time())}\"\n",
        "    os.makedirs(temp_dir, exist_ok=True)\n",
        "\n",
        "    temp_files = []\n",
        "    failed_files = []\n",
        "\n",
        "    for i, paragraph in enumerate(paragraphs):\n",
        "        voice = voices[i % len(voices)]\n",
        "        temp_file = f\"{temp_dir}/part_{i + 1}_{voice.split('-')[2]}.mp3\"\n",
        "\n",
        "        result = await generate_audio_for_paragraph(paragraph, voice, temp_file)\n",
        "        if result and os.path.exists(result):\n",
        "            temp_files.append(result)\n",
        "        else:\n",
        "            print(f\"Error generating {temp_file}, adding to retry list.\")\n",
        "            failed_files.append((paragraph, temp_file, voice))\n",
        "\n",
        "        await asyncio.sleep(0.1)\n",
        "\n",
        "    for paragraph, temp_file, voice in failed_files:\n",
        "        print(f\"Retrying generation for {temp_file}...\")\n",
        "        result = await generate_audio_for_paragraph(paragraph, voice, temp_file)\n",
        "        if result and os.path.exists(result):\n",
        "            temp_files.append(result)\n",
        "        else:\n",
        "            print(f\"Failed again: {temp_file}. Skipping.\")\n",
        "\n",
        "    combined = AudioSegment.empty()\n",
        "    pause = AudioSegment.silent(duration=500)\n",
        "\n",
        "    for i, temp_file in enumerate(temp_files):\n",
        "        valid_file = validate_and_fix_mp3(temp_file)\n",
        "        if valid_file:\n",
        "            audio_segment = AudioSegment.from_mp3(valid_file)\n",
        "            combined += audio_segment\n",
        "            if i < len(temp_files) - 1:\n",
        "                combined += pause\n",
        "        else:\n",
        "            print(f\"Skipping invalid file: {temp_file}\")\n",
        "\n",
        "    output_file = f\"{temp_dir}/final_output_{user_id}.mp3\"\n",
        "    combined.export(output_file, format=\"mp3\")\n",
        "\n",
        "    for temp_file in temp_files:\n",
        "        try:\n",
        "            release_file(temp_file)\n",
        "            if os.path.exists(temp_file):\n",
        "                os.remove(temp_file)\n",
        "        except Exception as e:\n",
        "            print(f\"Error removing {temp_file}: {e}\")\n",
        "\n",
        "    return output_file\n",
        "\n",
        "\n",
        "@client.on(events.NewMessage(pattern='/start'))\n",
        "async def start(event):\n",
        "    \"\"\"Handle the /start command.\"\"\"\n",
        "    await event.respond(\"سلام! فایل خود را ارسال کنید تا به گفتار تبدیل کنم.\")\n",
        "\n",
        "\n",
        "@client.on(events.NewMessage(incoming=True, func=lambda e: e.file))\n",
        "async def handle_file_message(event):\n",
        "    \"\"\"Process incoming file messages.\"\"\"\n",
        "    user_id = event.sender_id\n",
        "\n",
        "    if user_id in user_locks:\n",
        "        await event.respond(\"لطفاً منتظر بمانید تا فایل قبلی شما پردازش شود.\")\n",
        "        return\n",
        "\n",
        "    user_locks.add(user_id)  # Lock this user\n",
        "\n",
        "    async with file_lock:\n",
        "        try:\n",
        "            processing_msg = await event.respond(\"در حال پردازش فایل و تولید صوت...\")\n",
        "\n",
        "            file_path = await event.download_media()\n",
        "            text = extract_text_from_file(file_path)\n",
        "\n",
        "            output_file = await process_text_to_speech(text, user_id)\n",
        "\n",
        "            audio = AudioSegment.from_mp3(output_file)\n",
        "            duration = len(audio) / 1000\n",
        "\n",
        "            await client.send_file(\n",
        "                event.chat_id,\n",
        "                output_file,\n",
        "                voice_note=True,\n",
        "                attributes=[DocumentAttributeAudio(\n",
        "                    duration=int(duration), voice=True)],\n",
        "            )\n",
        "\n",
        "            release_file(output_file)\n",
        "            if os.path.exists(output_file):\n",
        "                os.remove(output_file)\n",
        "            os.rmdir(os.path.dirname(output_file))\n",
        "\n",
        "            await processing_msg.delete()\n",
        "\n",
        "        except Exception as e:\n",
        "            await event.respond(f\"متاسفانه خطایی رخ داد: {str(e)}\")\n",
        "\n",
        "        finally:\n",
        "            user_locks.remove(user_id)  # Unlock the user\n",
        "\n",
        "\n",
        "@client.on(events.NewMessage(incoming=True))\n",
        "async def handle_text_message(event):\n",
        "    \"\"\"Process incoming text messages and Telegram posts.\"\"\"\n",
        "    user_id = event.sender_id\n",
        "\n",
        "    if user_id in user_locks:\n",
        "        await event.respond(\"لطفاً منتظر بمانید تا فایل قبلی شما پردازش شود.\")\n",
        "        return\n",
        "\n",
        "    # Only process if it's a message and not a file\n",
        "    if not event.file:\n",
        "        user_locks.add(user_id)  # Lock this user\n",
        "\n",
        "        async with file_lock:\n",
        "            try:\n",
        "                processing_msg = await event.respond(\"در حال پردازش پیام و تولید صوت...\")\n",
        "\n",
        "                # Extract text and clean it\n",
        "                text = event.message.message\n",
        "                cleaned_text = clean_text(text)\n",
        "\n",
        "                # Generate audio from cleaned text\n",
        "                output_file = await process_text_to_speech(cleaned_text, user_id)\n",
        "\n",
        "                # Load and get the duration of the audio\n",
        "                audio = AudioSegment.from_mp3(output_file)\n",
        "                duration = len(audio) / 1000\n",
        "\n",
        "                await client.send_file(\n",
        "                    event.chat_id,\n",
        "                    output_file,\n",
        "                    voice_note=True,\n",
        "                    attributes=[DocumentAttributeAudio(duration=int(duration), voice=True)],\n",
        "                )\n",
        "\n",
        "                release_file(output_file)\n",
        "                if os.path.exists(output_file):\n",
        "                    os.remove(output_file)\n",
        "                os.rmdir(os.path.dirname(output_file))\n",
        "\n",
        "                await processing_msg.delete()\n",
        "\n",
        "            except Exception as e:\n",
        "                await event.respond(f\"متاسفانه خطایی رخ داد: {str(e)}\")\n",
        "\n",
        "            finally:\n",
        "                user_locks.remove(user_id)  # Unlock the user\n",
        "\n",
        "# Adjust the main function to directly await in Colab\n",
        "async def main():\n",
        "    \"\"\"Start the bot.\"\"\"\n",
        "    try:\n",
        "        print(\"Bot started...\")\n",
        "        async with client:  # Use async with for the client context\n",
        "            me = await client.get_me()\n",
        "            #print(f\"Bot info: @{me.username}\")\n",
        "            await client.run_until_disconnected()\n",
        "    except Exception as e:\n",
        "        print(f\"Bot error: {e}\")\n",
        "        time.sleep(5)\n",
        "\n",
        "# Run main if inside an async environment\n",
        "if __name__ == '__main__':\n",
        "    await main()\n"
      ],
      "metadata": {
        "id": "fEwr_3bsU-TK"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}