chore: rebrand project to realtime-dual-transcriber

Author: Diyoncrz18

.env.example

@@ -8,9 +8,9 @@ GROQ_TRANSLATION_MODEL=llama-3.1-8b-instant
 # GROQ_TRANSCRIPTION_PROMPT=Conversation with technical terms and product names.
 
 # Optional realtime tuning
-# ECOUTE_RECORD_TIMEOUT=1.4
-# ECOUTE_PHRASE_TIMEOUT=5.0
-# ECOUTE_PAUSE_THRESHOLD=0.65
-# ECOUTE_MIN_AUDIO_SECONDS=0.45
-# ECOUTE_MIN_AUDIO_RMS=120
-# ECOUTE_TRANSLATION_SILENCE_DELAY=5.0
+# RTDT_RECORD_TIMEOUT=1.4
+# RTDT_PHRASE_TIMEOUT=5.0
+# RTDT_PAUSE_THRESHOLD=0.65
+# RTDT_MIN_AUDIO_SECONDS=0.45
+# RTDT_MIN_AUDIO_RMS=120
+# RTDT_TRANSLATION_SILENCE_DELAY=5.0

.github/FUNDING.yml

@@ -46,13 +46,13 @@ def get_config(name, default):
     return str(value)
 
 
-RECORD_TIMEOUT = float(get_config("ECOUTE_RECORD_TIMEOUT", "1.4"))
-ENERGY_THRESHOLD = int(get_config("ECOUTE_ENERGY_THRESHOLD", "300"))
-DYNAMIC_ENERGY_THRESHOLD = get_config("ECOUTE_DYNAMIC_ENERGY_THRESHOLD", "1") != "0"
-PAUSE_THRESHOLD = float(get_config("ECOUTE_PAUSE_THRESHOLD", "0.65"))
-PHRASE_THRESHOLD = float(get_config("ECOUTE_PHRASE_THRESHOLD_SECONDS", "0.25"))
-NON_SPEAKING_DURATION = float(get_config("ECOUTE_NON_SPEAKING_DURATION", "0.35"))
-NOISE_ADJUST_SECONDS = float(get_config("ECOUTE_NOISE_ADJUST_SECONDS", "0.6"))
+RECORD_TIMEOUT = float(get_config("RTDT_RECORD_TIMEOUT", "1.4"))
+ENERGY_THRESHOLD = int(get_config("RTDT_ENERGY_THRESHOLD", "300"))
+DYNAMIC_ENERGY_THRESHOLD = get_config("RTDT_DYNAMIC_ENERGY_THRESHOLD", "1") != "0"
+PAUSE_THRESHOLD = float(get_config("RTDT_PAUSE_THRESHOLD", "0.65"))
+PHRASE_THRESHOLD = float(get_config("RTDT_PHRASE_THRESHOLD_SECONDS", "0.25"))
+NON_SPEAKING_DURATION = float(get_config("RTDT_NON_SPEAKING_DURATION", "0.35"))
+NOISE_ADJUST_SECONDS = float(get_config("RTDT_NOISE_ADJUST_SECONDS", "0.6"))
 
 
 class BaseRecorder:

AudioRecorder.py

@@ -54,13 +54,13 @@ def get_config(name, default):
     return str(value)
 
 
-PHRASE_TIMEOUT = float(get_config("ECOUTE_PHRASE_TIMEOUT", "5.0"))
-MAX_PHRASES = int(get_config("ECOUTE_MAX_PHRASES", "12"))
-MIN_AUDIO_SECONDS = float(get_config("ECOUTE_MIN_AUDIO_SECONDS", "0.45"))
-MIN_AUDIO_RMS = int(get_config("ECOUTE_MIN_AUDIO_RMS", "120"))
+PHRASE_TIMEOUT = float(get_config("RTDT_PHRASE_TIMEOUT", "5.0"))
+MAX_PHRASES = int(get_config("RTDT_MAX_PHRASES", "12"))
+MIN_AUDIO_SECONDS = float(get_config("RTDT_MIN_AUDIO_SECONDS", "0.45"))
+MIN_AUDIO_RMS = int(get_config("RTDT_MIN_AUDIO_RMS", "120"))
 TRANSLATION_SILENCE_DELAY = max(
     PHRASE_TIMEOUT,
-    float(get_config("ECOUTE_TRANSLATION_SILENCE_DELAY", str(PHRASE_TIMEOUT))),
+    float(get_config("RTDT_TRANSLATION_SILENCE_DELAY", str(PHRASE_TIMEOUT))),
 )
 TRANSLATION_WAITING_TEXT = "⏳ Menunggu pembicara berhenti..."
 TRANSLATION_RUNNING_TEXT = "Menerjemahkan..."
@@ -85,7 +85,7 @@ def __init__(self, mic_source, speaker_source, model):
         self.transcript_data = {"You": [], "Speaker": []}
         self.transcript_changed_event = threading.Event()
         self.audio_model = model
-        self.debug = os.environ.get("ECOUTE_DEBUG", "0") == "1"
+        self.debug = os.environ.get("RTDT_DEBUG", "0") == "1"
         self.lock = threading.RLock()
         self.revision = 0
         self.next_transcript_id = 1

AudioTranscriber.py

@@ -1,151 +1,204 @@
+# realtime-dual-transcriber
 
-# 🎧 Ecoute
+realtime-dual-transcriber is a Windows desktop application for live transcription from two audio sources at the same time:
 
-Ecoute is a live transcription tool that provides real-time transcripts for both the user's microphone input (You) and the user's speakers output (Speaker) in a textbox.
+- microphone input, shown as `You`
+- system speaker output, shown as `Speaker`
 
-## Sponsored By: Recall.ai - Meeting Transcription API
+The application displays a real-time transcript in a desktop UI and can optionally use an OpenAI-compatible API provider such as Groq for faster multilingual transcription and Indonesian translation.
 
-If you’re working with speech detection or transcription for meetings, consider checking out [Recall.ai](https://www.recall.ai/product/meeting-transcription-api/?utm_source=github&utm_medium=sponsorship&utm_campaign=sevask-ecoute), an API that works with Zoom, Google Meet, Microsoft Teams, and more. Recall.ai diarizes by pulling the speaker data and separate audio streams from the meeting platforms, which means 100% accurate speaker diarization with actual speaker names and speaker emails.
+## Key Features
 
-## 📖 Demo
+- Dual-source transcription for microphone and speaker audio
+- Desktop interface built with CustomTkinter
+- WASAPI loopback support for capturing default speaker output on Windows
+- Local transcription mode with Faster Whisper
+- API transcription mode with Groq or another OpenAI-compatible endpoint
+- Optional Indonesian translation for each finalized transcript block
+- Configurable silence delay, phrase timeout, audio filtering, and transcription model
+- Secret-safe local configuration through `.env` or `keys.py`
+- Built-in unit tests for transcript state and API authentication handling
 
-https://github.com/user-attachments/assets/5616421f-838d-439f-8b15-0df7b8d33459
+## Repository
 
-Ecoute is designed to help users in their conversations by providing live transcriptions.
+```powershell
+git clone https://github.com/Diyoncrz18/realtime-dual-transcriber.git
+cd realtime-dual-transcriber
+```
 
-## 🚀 Getting Started
+## Requirements
 
-Follow these steps to set up and run Ecoute on your local machine.
+- Windows 10 or Windows 11
+- Python 3.8 or newer
+- FFmpeg available on `PATH`
+- Working microphone and default speaker device
+- Optional: Groq or OpenAI-compatible API key for API mode
 
-### 📋 Prerequisites
+Install FFmpeg with Chocolatey:
 
-- Python >=3.8.0
-- (Optional) An OpenAI API key that can access Whisper API (set up a paid account OpenAI account)
-- Windows OS (Not tested on others)
-- FFmpeg 
+```powershell
+choco install ffmpeg
+```
 
-If FFmpeg is not installed in your system, you can follow the steps below to install it.
+Or install FFmpeg manually and make sure `ffmpeg.exe` is available from PowerShell:
 
-First, you need to install Chocolatey, a package manager for Windows. Open your PowerShell as Administrator and run the following command:
+```powershell
+ffmpeg -version
 ```
-Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
-```
-Once Chocolatey is installed, you can install FFmpeg by running the following command in your PowerShell:
-```
-choco install ffmpeg
+
+## Installation
+
+Create and activate a virtual environment:
+
+```powershell
+python -m venv .venv
+.\.venv\Scripts\Activate.ps1
 ```
-Please ensure that you run these commands in a PowerShell window with administrator privileges. If you face any issues during the installation, you can visit the official Chocolatey and FFmpeg websites for troubleshooting.
 
-### 🔧 Installation
+Install dependencies:
 
-1. Clone the repository:
+```powershell
+python -m pip install --upgrade pip
+pip install -r requirements.txt
+```
 
-   ```
-   git clone https://github.com/SevaSk/ecoute
-   ```
+## Configuration
 
-2. Navigate to the `ecoute` folder:
+The recommended configuration method is `.env`.
 
-   ```
-   cd ecoute
-   ```
+```powershell
+Copy-Item .env.example .env
+```
 
-3. Install the required packages:
+Edit `.env` and replace placeholder values with your own credentials.
 
-   ```
-   pip install -r requirements.txt
-   ```
-   
-4. (Optional) Configure API credentials locally.
+Groq example:
 
-   The safest option is to copy the example environment file and add your real API key to `.env`:
+```env
+GROQ_API_KEY=your-groq-api-key-here
+GROQ_TRANSCRIPTION_MODEL=whisper-large-v3-turbo
+GROQ_TRANSLATION_MODEL=llama-3.1-8b-instant
+```
 
-   ```
-   Copy-Item .env.example .env
-   ```
+OpenAI-compatible endpoint example:
 
-   Example Groq setup:
+```env
+OPENAI_API_KEY=your-openai-compatible-api-key
+OPENAI_BASE_URL=https://your-provider.example/v1
+OPENAI_TRANSCRIPTION_MODEL=whisper-1
+```
 
-   ```
-   GROQ_API_KEY=your-groq-api-key-here
-   GROQ_TRANSCRIPTION_MODEL=whisper-large-v3-turbo
-   GROQ_TRANSLATION_MODEL=llama-3.1-8b-instant
-   ```
+You can also configure credentials through `keys.py`:
 
-   Example OpenAI-compatible setup:
+```powershell
+Copy-Item keys.example.py keys.py
+```
 
-   ```
-   OPENAI_API_KEY=your-openai-api-key-here
-   OPENAI_BASE_URL=https://your-custom-api.example/v1
-   OPENAI_TRANSCRIPTION_MODEL=whisper-1
-   ```
+Keep real credentials local. `.env` and `keys.py` are ignored by Git and should never be committed.
 
-   You can also use `CUSTOM_API_KEY`, `CUSTOM_API_URL`, and `CUSTOM_API_TRANSCRIPTION_MODEL` with the same values.
+## Runtime Tuning
 
-   If you prefer Python config, copy `keys.example.py` to `keys.py` and put your real values there.
-   Do not commit `.env` or `keys.py`; both files are ignored by `.gitignore`.
+These values are optional and can be added to `.env` when needed:
 
-   If you see `Invalid API Key` or `expired_api_key`, create a new provider key and replace the old value in `.env` or `keys.py`, then restart Ecoute.
+```env
+GROQ_TRANSCRIPTION_LANGUAGE=id
+GROQ_TRANSCRIPTION_TEMPERATURE=0
+GROQ_TRANSCRIPTION_PROMPT=Conversation with technical terms and product names.
 
-   Optional tuning:
+RTDT_RECORD_TIMEOUT=1.4
+RTDT_PHRASE_TIMEOUT=5.0
+RTDT_PAUSE_THRESHOLD=0.65
+RTDT_MIN_AUDIO_SECONDS=0.45
+RTDT_MIN_AUDIO_RMS=120
+RTDT_TRANSLATION_SILENCE_DELAY=5.0
+```
 
-      ```
-      GROQ_TRANSCRIPTION_MODEL=whisper-large-v3
-      GROQ_TRANSCRIPTION_LANGUAGE=id
-      GROQ_TRANSCRIPTION_TEMPERATURE=0
-      GROQ_TRANSCRIPTION_PROMPT=Conversation with technical terms and product names.
-      ```
+Model recommendation:
 
-   Use `whisper-large-v3-turbo` for lower latency, or `whisper-large-v3` when accuracy matters more.
+- `whisper-large-v3-turbo` for lower latency
+- `whisper-large-v3` for higher accuracy
 
-   A new transcript block is created only after a mic or speaker segment has been quiet for about 5 seconds. Tune that delay with:
+## Running the Application
 
-      ```
-      ECOUTE_RECORD_TIMEOUT=1.4
-      ECOUTE_PHRASE_TIMEOUT=5.0
-      ECOUTE_TRANSLATION_SILENCE_DELAY=5.0
-      ```
+Run local transcription mode:
 
-### 🎬 Running Ecoute
+```powershell
+.\.venv\Scripts\python.exe main.py
+```
 
-Run the main script:
+Run API transcription mode:
 
+```powershell
+.\.venv\Scripts\python.exe main.py --api
 ```
-python main.py
+
+API mode is recommended when you need better multilingual support, faster transcription, and Indonesian translation.
+
+## How It Works
+
+1. `AudioRecorder.py` captures microphone audio and default speaker loopback audio.
+2. `AudioTranscriber.py` filters short or silent audio, merges phrase fragments, and manages transcript state.
+3. `TranscriberModels.py` routes transcription to either Faster Whisper or an OpenAI-compatible API provider.
+4. `main.py` renders the live transcript UI and refreshes it as transcript revisions change.
+
+## Project Structure
+
+```text
+.
+|-- AudioRecorder.py              # Microphone and speaker recording
+|-- AudioTranscriber.py           # Transcript state, merging, filtering, translation queue
+|-- TranscriberModels.py          # Local and API transcription providers
+|-- main.py                       # Desktop UI entry point
+|-- custom_speech_recognition/    # Speech recognition compatibility layer
+|-- tests/                        # Unit tests
+|-- .env.example                  # Environment variable template
+|-- keys.example.py               # Python credential template
+|-- requirements.txt              # Python dependencies
+`-- README.md                     # Project documentation
 ```
 
-For a more better and faster version that also works with most languages, use:
+## Testing
+
+Run the unit test suite:
 
+```powershell
+.\.venv\Scripts\python.exe -m unittest discover -s tests
 ```
-python main.py --api
+
+Compile-check the main Python files:
+
+```powershell
+.\.venv\Scripts\python.exe -m py_compile main.py AudioRecorder.py AudioTranscriber.py TranscriberModels.py
 ```
 
-Upon initiation, Ecoute will begin transcribing your microphone input and speaker output in real-time. Please note that it might take a few seconds for the system to warm up before the transcription becomes real-time.
+## Troubleshooting
 
-The --api flag will use the whisper api for transcriptions. This significantly enhances transcription speed and accuracy, and it works in most languages (rather than just English without the flag). It's expected to become the default option in future releases. However, keep in mind that using the Whisper API will consume more OpenAI credits than using the local model. This increased cost is attributed to the advanced features and capabilities that the Whisper API provides. Despite the additional expense, the substantial improvements in speed and transcription accuracy may make it a worthwhile investment for your use case.
+### Invalid or expired API key
 
-### ✅ Testing
+If the terminal shows `Invalid API Key` or `expired_api_key`, create a new provider key, update `.env` or `keys.py`, and restart the application.
 
-Run the unit tests with:
+### FFmpeg not found
 
-```
-python -m unittest discover -s tests
-```
+Make sure FFmpeg is installed and available from PowerShell:
 
-### ⚠️ Limitations
+```powershell
+ffmpeg -version
+```
 
-While Ecoute provides real-time transcription and response suggestions, there are several known limitations to its functionality that you should be aware of:
+### Speaker audio is not captured
 
-**Default Mic and Speaker:** Ecoute is currently configured to listen only to the default microphone and speaker set in your system. It will not detect sound from other devices or systems. If you wish to use a different mic or speaker, you will need to set it as your default device in your system settings.
+The application captures the default Windows speaker output through WASAPI loopback. Set the target output device as the Windows default speaker before starting the app.
 
-**Whisper Model**: If the --api flag is not used, we utilize the 'tiny' version of the Whisper ASR model, due to its low resource consumption and fast response times. However, this model may not be as accurate as the larger models in transcribing certain types of speech, including accents or uncommon words.
+### Transcription is delayed
 
-**Language**: If you are not using the --api flag the Whisper model used in Ecoute is set to English. As a result, it may not accurately transcribe non-English languages or dialects. We are actively working to add multi-language support to future versions of the program.
+Transcript blocks are finalized after a silence delay. Lower `RTDT_TRANSLATION_SILENCE_DELAY` and `RTDT_PHRASE_TIMEOUT` for faster updates, or increase them for more stable sentence grouping.
 
-## 📖 License
+## Security Notes
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+- Do not commit `.env`, `keys.py`, model files, recordings, or logs.
+- The repository includes a GitHub Actions secret scan for common API key patterns.
+- If a real API key was ever committed, revoke it immediately and create a new one.
 
-## 🤝 Contributing
+## Maintainer
 
-Contributions are welcome! Feel free to open issues or submit pull requests to improve Ecoute.
+Maintained by `Diyoncrz18`.

README.md

@@ -109,7 +109,7 @@ def __init__(self, api_key=None, base_url=None, model=None):
             "CUSTOM_API_TRANSCRIPTION_TEMPERATURE",
             default=0.0,
         )
-        self.translation_enabled = self._get_config("ECOUTE_ENABLE_TRANSLATION", default="1") != "0"
+        self.translation_enabled = self._get_config("RTDT_ENABLE_TRANSLATION", default="1") != "0"
         self.last_error = None
         self.last_error_time = 0
         self.api_available = True
@@ -282,7 +282,7 @@ def _disable_api_after_auth_error(self, error):
         self.auth_error_logged = True
         print(
             "[ERROR] API key rejected by provider. "
-            "Update GROQ_API_KEY in .env or keys.py, then restart Ecoute. "
+            "Update GROQ_API_KEY in .env or keys.py, then restart realtime-dual-transcriber. "
             f"Provider response: {error}"
         )
 

TranscriberModels.py

@@ -6,6 +6,6 @@
 # GROQ_TRANSCRIPTION_LANGUAGE = "id"
 # GROQ_TRANSCRIPTION_TEMPERATURE = "0"
 # GROQ_TRANSCRIPTION_PROMPT = "Conversation with technical terms and product names."
-# ECOUTE_RECORD_TIMEOUT = "1.4"
-# ECOUTE_PHRASE_TIMEOUT = "5.0"
-# ECOUTE_TRANSLATION_SILENCE_DELAY = "5.0"
+# RTDT_RECORD_TIMEOUT = "1.4"
+# RTDT_PHRASE_TIMEOUT = "5.0"
+# RTDT_TRANSLATION_SILENCE_DELAY = "5.0"