Upload 4 files

added files related to my project

Dockerfile

@@ -0,0 +1,26 @@
+
+# Use the official Python 3.9 image as the base for the container, providing the Python runtime environment.
+FROM python:3.9  
+
+# Set the working directory inside the container to /code where all subsequent commands will be executed.
+WORKDIR /code  
+
+# Copy the requirements.txt file from the host to the /code directory in the container. This file lists all the Python dependencies needed for the application.
+COPY ./requirements.txt /code/requirements.txt  
+
+# Install the Python dependencies specified in requirements.txt using pip. 
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt  
+# --no-cache-dir prevents pip from caching packages, reducing the image size.
+# --upgrade ensures that the latest compatible versions of the dependencies are installed.
+# Example: If requirements.txt contains "fastapi==0.70.0", this command will install FastAPI version 0.70.0.
+
+# Copy all files from the current directory on the host machine into the /code directory inside the container. 
+COPY . /code  
+# This includes the application code, configuration files, and any other necessary resources.
+
+# Define the default command to run when the container starts.
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]  
+# This command launches the Uvicorn server to serve the FastAPI application defined in app.py.
+# --host "0.0.0.0" makes the server accessible externally.
+# --port "7860" sets the port on which the application will listen.
+# Example: Running this command starts the web server, allowing users to access the Telegram Voice Transcription Bot via port 7860.

app.py

@@ -0,0 +1,64 @@
+from fastapi import FastAPI, Request, Response  # Import FastAPI classes for creating the web app and handling requests/responses
+from async_tgvoicebot import handle_message    # Import the asynchronous function to handle incoming Telegram messages
+import aiohttp                                 # Import aiohttp for making asynchronous HTTP requests
+import os                                      # Import os module to access environment variables
+
+app = FastAPI()                                 # Initialize a FastAPI application instance
+
+# Retrieve the Telegram bot token from environment variables
+TELEGRAM_BOT_TOKEN = os.environ.get('TELEGRAM_BOT_TOKEN')
+# Retrieve the secret token for webhook security from environment variables
+SECRET_TOKEN = os.environ.get('SECRET_TOKEN')
+
+@app.post("/webhook")
+async def webhook(request: Request):
+    """
+    Endpoint to receive webhook updates from Telegram.
+    Only processes the update if the secret token matches (if provided).
+    """
+    # Check if a secret token is set for additional security
+    if SECRET_TOKEN:
+        # Compare the secret token in the request headers with the expected SECRET_TOKEN
+        if request.headers.get('X-Telegram-Bot-Api-Secret-Token') != SECRET_TOKEN:
+            # If tokens do not match, respond with 403 Forbidden status
+            return Response(status_code=403)
+
+    # Parse the incoming JSON payload from the request
+    update = await request.json()
+    # Create an asynchronous HTTP session
+    async with aiohttp.ClientSession() as session:
+        # Call the handle_message function with the current session and the message part of the update
+        await handle_message(session, update.get('message', {}))
+    # Respond to Telegram that the update was received and processed successfully
+    return {"status": "ok"}
+
+@app.get("/")
+async def root():
+    """
+    Root endpoint to confirm that the Telegram Bot is running.
+    """
+    # Return a simple JSON message indicating the bot's status
+    return {"message": "Telegram Bot is running"}
+
+# Endpoint to set webhook
+@app.get("/set_webhook")
+async def set_webhook():
+    """
+    Endpoint to set the Telegram webhook to the specified URL.
+    This should be called after deploying the bot to ensure Telegram sends updates to the correct endpoint.
+    """
+    # Construct the webhook URL using the SPACE_ID environment variable
+    webhook_url = f"https://{os.environ.get('SPACE_ID')}.hf.space/webhook"
+    # Telegram API URL to set the webhook
+    set_webhook_url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/setWebhook"
+    # Payload containing the webhook URL and the secret token for security
+    payload = {
+        "url": webhook_url,
+        "secret_token": SECRET_TOKEN
+    }
+    # Create an asynchronous HTTP session
+    async with aiohttp.ClientSession() as session:
+        # Send a POST request to Telegram's setWebhook API with the payload
+        async with session.post(set_webhook_url, json=payload) as response:
+            # Await and return the JSON response from Telegram confirming the webhook setup
+            return await response.json()

async_ai_voice.py

@@ -0,0 +1,60 @@
+import aiohttp  # Import aiohttp for making asynchronous HTTP requests
+import os        # Import os to access environment variables
+import json      # Import json to handle JSON data
+from typing import Dict, Any  # Import type hints for better code clarity
+
+# Define the API endpoint URL for the Hugging Face Whisper model
+API_URL = "https://api-inference.huggingface.co/models/distil-whisper/distil-large-v3"
+
+# Set up the headers with the authorization token retrieved from environment variables
+headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_API_KEY')}"}
+
+async def send_to_voice_AI(audio_data: bytes) -> Dict[str, Any]:
+    """
+    Asynchronously sends audio data to the Hugging Face Whisper model for transcription.
+
+    Args:
+        audio_data (bytes): The raw audio data to be transcribed.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the transcription result or error message.
+    """
+    print("Sending to voice AI")  # Log the action for debugging purposes
+
+    # Create an asynchronous HTTP session using aiohttp
+    async with aiohttp.ClientSession() as session:
+        try:
+            # Asynchronously send a POST request to the API_URL with headers and audio data
+            async with session.post(API_URL, headers=headers, data=audio_data) as response:
+                # Await the response to ensure the request completes before proceeding
+                if response.status == 200:
+                    # If the response is successful, await and return the JSON content
+                    return await response.json()
+                else:
+                    # If the response status is not 200, await the text of the response
+                    error_text = await response.text()
+                    # Parse the error text into a JSON object
+                    error_json = json.loads(error_text)
+                    # Return a dictionary with an error message and estimated loading time
+                    return {
+                        "text": f"error: {error_json.get('error', 'Unknown error')}\n"
+                                f"Estimated time to load: {error_json.get('estimated_time', 'unknown')} seconds"
+                    }
+        except aiohttp.ClientError as e:
+            # Handle any client-related errors that occur during the request
+            return {"text": f"Network error: {str(e)}"}
+        except json.JSONDecodeError:
+            # Handle errors that occur if the response cannot be parsed as JSON
+            return {"text": "Error: Unable to parse API response"}
+
+# Example usage:
+# The following example demonstrates how to use the send_to_voice_AI function asynchronously.
+# It reads an audio file, sends it to the voice AI, and prints the output.
+
+# import asyncio  # Import asyncio to run the asynchronous function
+# async def example():
+#     with open("sample1.flac", "rb") as f:  # Open the audio file in binary read mode
+#         audio_data = f.read()  # Read the audio data from the file
+#     output = await send_to_voice_AI(audio_data)  # Await the asynchronous transcription function
+#     print(output)  # Print the transcription result
+# asyncio.run(example())  # Run the asynchronous example function

async_tgvoicebot.py

@@ -0,0 +1,44 @@
+import asyncio  # Imports the asyncio library for writing single-threaded concurrent code using coroutines
+import aiohttp  # Imports aiohttp for making asynchronous HTTP requests
+import os  # Imports the os module to interact with the operating system
+from dotenv import load_dotenv  # Imports load_dotenv to load environment variables from a .env file
+load_dotenv()  # Loads environment variables from the .env file into the program's environment
+from async_ai_voice import send_to_voice_AI  # Imports the send_to_voice_AI function from the async_ai_voice module
+
+# Telegram Bot API setup
+TELEGRAM_BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')  # Retrieves the Telegram bot token from environment variables
+TELEGRAM_API_URL = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}"  # Constructs the base Telegram API URL using the bot token
+
+async def get_voice_file(session, file_id):
+    """
+    Asynchronous function to retrieve the voice file from Telegram using the file ID.
+    """
+    # Get file path
+    file_path_url = f"{TELEGRAM_API_URL}/getFile?file_id={file_id}"  # Constructs the URL to get file information from Telegram
+    async with session.get(file_path_url) as response:  # Asynchronously sends a GET request to the file_path_url
+        file_info = await response.json()  # Awaits and parses the JSON response containing file information
+        file_path = file_info['result']['file_path']  # Extracts the file path from the response
+    
+    # Download file
+    file_url = f"https://api.telegram.org/file/bot{TELEGRAM_BOT_TOKEN}/{file_path}"  # Constructs the URL to download the actual voice file
+    async with session.get(file_url) as response:  # Asynchronously sends a GET request to download the file
+        return await response.read()  # Awaits and returns the raw bytes of the downloaded file
+
+async def handle_message(session, message):
+    """
+    Asynchronous function to handle incoming Telegram messages.
+    """
+    if 'voice' in message:  # Checks if the incoming message contains a voice message
+        file_id = message['voice']['file_id']  # Retrieves the file ID of the voice message
+        audio_data = await get_voice_file(session, file_id)  # Awaits the retrieval of the audio data using the get_voice_file function
+        transcription = await send_to_voice_AI(audio_data)  # Awaits the transcription of the audio data using the AI service
+        
+        # Send transcription back to user
+        chat_id = message['chat']['id']  # Retrieves the chat ID to identify where to send the response
+        text = transcription.get('text', 'Sorry, could not transcribe the audio due to AI error.')  # Gets the transcribed text or a default error message
+        send_message_url = f"{TELEGRAM_API_URL}/sendMessage"  # Constructs the URL to send a message via the Telegram API
+        payload = {
+            'chat_id': chat_id,  # Specifies the chat ID where the message should be sent
+            'text': text  # The transcribed text to send back to the user
+        }
+        await session.post(send_message_url, json=payload)  # Asynchronously sends a POST request to send the transcription back to the user