Upload folder using huggingface_hub

.firebaserc

@@ -0,0 +1,5 @@
+{
+  "projects": {
+    "default": "ai-language-detector"
+  }
+}

.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+flagged
+audio

README.md

@@ -1,12 +1,6 @@
 ---
-title: AI Language Detector
-emoji: 🦀
-colorFrom: gray
-colorTo: indigo
+title: AI_Language_Detector
+app_file: main.py
 sdk: gradio
-sdk_version: 4.19.2
-app_file: app.py
-pinned: false
+sdk_version: 4.19.1
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

firebase.json

@@ -0,0 +1,23 @@
+{
+  "functions": [
+    {
+      "source": "functions",
+      "codebase": "default",
+      "ignore": [
+        "venv",
+        ".git",
+        "firebase-debug.log",
+        "firebase-debug.*.log"
+      ]
+    }
+  ],
+  "emulators": {
+    "functions": {
+      "port": 5001
+    },
+    "ui": {
+      "enabled": true
+    },
+    "singleProjectMode": true
+  }
+}

functions/backend/ai_processing/gpt.py

@@ -0,0 +1,38 @@
+import json
+import openai
+import os
+
+from .prompt import SYSTEM_PROMPT
+
+# Load your API key from an environment variable or secret management service
+
+def ai_language_detector(input_text:str) -> str | None:
+    try:
+        api_key = os.getenv("OPENAI_API_KEY")
+        client = openai.OpenAI(api_key=api_key)
+
+        completion = client.chat.completions.create(
+            response_format={"type": "json_object"},
+            model="gpt-4-0125-preview",
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": input_text},
+            ],
+        )
+
+        
+        content = json.loads(completion.choices[0].message.content or "{}")
+        if "language" not in content:
+            return None
+    
+        return content["language"]
+    
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None
+
+
+if __name__ == "__main__":
+    # Example usage:
+    print(ai_language_detector("hola como estas?"))

functions/backend/ai_processing/process_audio.py

@@ -0,0 +1,33 @@
+import os
+from backend.ai_processing.transcription import transcribe_audio_file_with_language
+from backend.ai_processing.gpt import ai_language_detector
+
+def process_audio(file_path: str) -> str:
+    """
+    Processes the audio file by transcribing it and detecting its language.
+    
+    - Takes the path to an audio file.
+    - Ensures the file exists.
+    - Uses the transcribe_audio_file_with_language function to transcribe the audio.
+    - Detects the language of the transcription.
+    - Raises FileNotFoundError if the file does not exist.
+    - Raises ValueError if the language cannot be detected (None).
+    - Returns the detected language as a string.
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File {file_path} not found.")
+    
+    transcription = transcribe_audio_file_with_language(file_path)
+    predicted_language = ai_language_detector(transcription)
+    
+    if predicted_language is None:
+        raise ValueError("Language could not be detected.")
+    
+    return predicted_language
+
+
+if __name__ == "__main__":
+    # Example usage
+    file_path = "path/to/audio/file.wav"
+    transcription = process_audio(file_path)
+    print(transcription)

functions/backend/ai_processing/prompt.py

@@ -0,0 +1,28 @@
+SYSTEM_PROMPT = """
+you are a language detection system. 
+
+you will be given a string of text. Your task is to determine the language of the text.
+
+you will only return a json object with the language of the text and language code in parentheses.
+
+examples:
+
+{
+    "language": "🇺🇸 ️English (en) "
+}
+
+or 
+
+{
+    "language": "🇫🇷 ️French (fr)"
+}
+
+or 
+
+{
+    "language": "🇪🇸 ️Spanish (es)"
+}
+
+
+"""
+

functions/backend/ai_processing/transcription.py

@@ -0,0 +1,35 @@
+import os
+import logging
+from openai import OpenAI
+
+# Transcribe audio file using OpenAI's Whisper model
+
+def transcribe_audio_file_with_language(file_path: str) -> str:
+    """
+    - Transcribe audio file using OpenAI's Whisper model
+    - Returns transcription as a string
+    - default language is English
+    """
+
+    # Initialize OpenAI client with API key
+    openai_api_key = os.environ.get("OPENAI_API_KEY")
+    client = OpenAI(api_key=openai_api_key)
+
+    logging.info(f"Transcribing audio file: {file_path}")
+
+    with open(file_path, "rb") as audio_file:
+        # Request transcription using Whisper model
+        transcript = client.audio.transcriptions.create(
+            model="whisper-1", file=audio_file, prompt="Transcribe this audio file and best guess the language."
+        )
+    
+    # Get the transcription text
+    transcription = transcript.text
+
+    return transcription
+
+if __name__ == "__main__":
+    # Test the function
+    file_path = "/Users/hassen/LocalDev/PYTHON_PROJECTS/GPTGenProjects/languageDetector/audio/recorded_audio.wav"
+    transcription = transcribe_audio_file_with_language(file_path)
+    print(transcription)

functions/main.py

@@ -0,0 +1,67 @@
+# Welcome to Cloud Functions for Firebase for Python!
+# To get started, simply uncomment the below code or create your own.
+# Deploy with `firebase deploy`
+
+from firebase_functions import https_fn
+from firebase_admin import initialize_app
+import io  # Ensure this import is added to handle BytesIO
+import tempfile
+import os
+
+from backend.ai_processing.gpt import ai_language_detector
+from backend.ai_processing.transcription import transcribe_audio_file_with_language
+
+
+initialize_app()
+
+@https_fn.on_request()
+def detect_language(req: https_fn.Request) -> https_fn.Response:
+    """
+    Cloud Function to detect language from an uploaded audio file.
+    
+    - Accepts POST requests with an audio file.
+    - Validates the file format (assumes WAV for this example).
+    - Reads the audio file content.
+    - Transcribes the audio content and detects the language.
+    - Returns the detected language as JSON.
+    """
+    if req.method != 'POST':
+        return https_fn.Response("Method Not Allowed", status=405)
+    
+    # Check if there is a file in the request
+    if 'file' not in req.files:
+        return https_fn.Response("No file part in the request", status=400)
+    
+    file = req.files['file']
+    
+    # Enforce a specific file format here, e.g., WAV
+    if not file or not file.filename or not file.filename.endswith(('.mp3', '.mp4', '.mpeg', '.mpga', '.m4a', '.wav', '.webm')):
+        return https_fn.Response("File format not supported.", status=400)
+    
+    try:
+        # Save the file to a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as tmp_file:
+            file_content = file.read()  # Read file content
+            tmp_file.write(file_content)  # Write content to temporary file
+            tmp_file_path = tmp_file.name  # Get the path of the temporary file
+        
+        # Process the audio file and detect language
+        transcription = transcribe_audio_file_with_language(tmp_file_path)
+        
+        # Clean up the temporary file
+        os.remove(tmp_file_path)
+        
+        # Detect the language from the transcription
+        predicted_language = ai_language_detector(transcription)
+        
+        if predicted_language is None:
+            raise ValueError("Language could not be detected.")
+        
+        # Return the detected language as JSON
+        return https_fn.Response(f"{predicted_language}", status=200, mimetype='application/json')
+    except ValueError as e:
+        # Handle specific errors, e.g., language not detected
+        return https_fn.Response(f"Error: {str(e)}", status=400)
+    except Exception as e:
+        # Handle errors (e.g., transcription failure, unsupported audio format)
+        return https_fn.Response(f"Error processing the audio file: {str(e)}", status=500)

functions/requirements.txt

@@ -0,0 +1,73 @@
+firebase_functions~=0.1.0
+aiofiles==23.2.1
+altair==5.2.0
+annotated-types==0.6.0
+anyio==4.3.0
+attrs==23.2.0
+certifi==2024.2.2
+cffi==1.16.0
+charset-normalizer==3.3.2
+click==8.1.7
+colorama==0.4.6
+contourpy==1.2.0
+cycler==0.12.1
+distro==1.9.0
+fastapi==0.109.2
+ffmpy==0.3.2
+filelock==3.13.1
+fonttools==4.49.0
+fsspec==2024.2.0
+gradio==4.19.1
+gradio_client==0.10.0
+h11==0.14.0
+httpcore==1.0.3
+httpx==0.26.0
+huggingface-hub==0.20.3
+idna==3.6
+importlib-resources==6.1.1
+Jinja2==3.1.3
+jsonschema==4.21.1
+jsonschema-specifications==2023.12.1
+kiwisolver==1.4.5
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.8.3
+mdurl==0.1.2
+numpy==1.26.4
+openai==1.12.0
+orjson==3.9.14
+packaging==23.2
+pandas==2.2.0
+pillow==10.2.0
+pycparser==2.21
+pydantic==2.6.1
+pydantic_core==2.16.2
+pydub==0.25.1
+Pygments==2.17.2
+pyparsing==3.1.1
+python-dateutil==2.8.2
+python-multipart==0.0.9
+pytz==2024.1
+PyYAML==6.0.1
+referencing==0.33.0
+requests==2.31.0
+rich==13.7.0
+rpds-py==0.18.0
+ruff==0.2.2
+scipy==1.12.0
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.0
+sounddevice==0.4.6
+soundfile==0.12.1
+starlette==0.36.3
+tomlkit==0.12.0
+toolz==0.12.1
+tqdm==4.66.2
+typer==0.9.0
+typing_extensions==4.9.0
+tzdata==2024.1
+urllib3==2.2.1
+uvicorn==0.27.1
+websockets==11.0.3

main.py

@@ -0,0 +1,74 @@
+import gradio as gr
+import numpy as np
+from scipy.io.wavfile import write
+import os
+import requests  # Import requests library
+
+# from backend.ai_processing.process_audio import process_audio  # Import the process_audio function
+
+# Define constants
+SAMPLE_RATE = 44100  # Sample rate in Hz
+AUDIO_DIR = 'audio'  # Directory to save audio files
+
+# Ensure the audio directory exists
+if not os.path.exists(AUDIO_DIR):
+    os.makedirs(AUDIO_DIR)
+
+def save_and_transcribe_audio(recording, filename='recording.wav'):
+    """
+    Saves the recorded audio to a file and sends it to an external API for transcription and language detection.
+    
+    - Extracts sample rate and audio data from the recording.
+    - Scales the audio data to 16-bit integers.
+    - Saves the audio data as a WAV file.
+    - Sends the saved audio file to an external API for transcription and language detection.
+    - Returns the response from the API.
+    """
+    # Ensure recording is not None
+    try:
+        # Attempt to extract sample rate and audio data
+        sample_rate, audio_data = recording
+    except TypeError:
+        raise ValueError("Invalid recording: Expected a tuple with sample rate and audio data, got None.")
+    except ValueError:
+        raise ValueError("Invalid recording: Expected a tuple with sample rate and audio data.")
+    
+    # Ensure audio_data is a NumPy array
+    audio_data = np.array(audio_data)
+    
+    # Scale the audio data to 16-bit integers
+    scaled = np.int16(audio_data/np.max(np.abs(audio_data)) * 32767)
+    
+    # Save as WAV file
+    filepath = os.path.join(AUDIO_DIR, filename)
+    write(filepath, sample_rate, scaled)
+    
+    # Send the audio file to the external API
+    with open(filepath, 'rb') as f:
+        files = {'file': (filename, f)}
+        response = requests.post('https://detect-language-tuwk5nvu4a-uc.a.run.app', files=files)
+    
+    if response.status_code == 200:
+        # Process successful response
+        return response.text
+    else:
+        # Handle error response
+        raise ValueError(f"API call failed with status code {response.status_code}: {response.text}")
+
+# Create Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("#AI Language Detector")
+    gr.Markdown("## Transcribe audio with OpenAI's Whisper model and use GPT to detect the language from the transcription text")
+    with gr.Row():
+        record_btn = gr.Audio(sources=['microphone'], type='numpy', label='Record Audio')
+        transcribe_btn = gr.Button('Detect Language')
+    
+    # Output message
+    output = gr.Textbox(label='Detected Language')
+    
+    # Define button action
+    transcribe_btn.click(fn=save_and_transcribe_audio, inputs=[record_btn], outputs=[output])
+
+# Launch the Gradio app
+if __name__ == "__main__":
+    demo.launch(share=True, )