scribe-cli 0.3.0__py3-none-any.whl

scribe/__init__.py

@@ -0,0 +1 @@
+from ._version import __version__

scribe/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)

scribe/audio.py

@@ -0,0 +1,51 @@
+import sounddevice as sd
+import queue
+
+
+def get_duration(audio_length_bytes, # bytes
+                sampling_rate = 16000,  # Hz
+                num_channels = 1,  # Mono
+                sample_width = 2,  # 16-bit audio
+                ):
+
+    # Calculate the number of samples
+    num_samples = audio_length_bytes / (num_channels * sample_width)
+
+    # Calculate the duration in seconds
+    duration_seconds = num_samples / sampling_rate
+
+    return duration_seconds
+
+
+class Microphone:
+    def __init__(self,
+            samplerate = 16000,  # Vosk models typically use a 16kHz sample rate
+            channels = 1,  # Mono audio
+            device = None,  # Default device
+            dtype = 'int16',  # Vosk models typically use 16-bit audio
+        ):
+        self.q = queue.Queue()
+        self.samplerate = samplerate
+        self.channels = channels
+        self.device = device
+        self.dtype = dtype
+
+    # Fonction callback pour traiter les morceaux audio
+    def callback(self, indata, frames, time, status):
+        if status:
+            print(status)
+        self.q.put(bytes(indata))
+        # if frames > 1000:  # Ajustez cette valeur pour essayer différents morceaux de taille
+    #     rec.AcceptWaveform(bytes(indata))
+
+
+    def open_stream(self):
+        self.q.queue.clear()
+        return sd.InputStream(samplerate=self.samplerate, device=self.device,
+                              channels=self.channels, callback=self.callback, dtype=self.dtype)
+
+    def device_info(self):
+        return sd.query_devices(self.device, 'input')
+
+    def get_duraction(self, audio_length_bytes):
+        return get_duration(audio_length_bytes, self.samplerate, self.channels, {'int16':2}[self.dtype])

scribe/install_desktop.py

@@ -0,0 +1,43 @@
+import os, sys, platform, shutil, sysconfig
+import argparse
+
+def main():
+
+    # Check if the current platform is Linux
+    if platform.system() != "Linux":
+        print("This package is only supported on Linux systems.", file=sys.stderr)
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser("Install the desktop file for the scribe package. Any arguments to this script will be passed on to `scribe`.")
+    o, rest = parser.parse_known_args()
+    o.arguments = rest
+
+    PACKAGE_NAME = 'scribe'
+
+    HOME = os.environ.get('HOME',os.path.expanduser('~'))
+    XDG_SHARE = os.environ.get('XDG_DATA_HOME', os.path.join(HOME, '.local','share'))
+    XDG_APP_DATA = os.path.join(XDG_SHARE, 'applications')
+    XDG_SCRIBE_DATA = os.path.join(XDG_SHARE, PACKAGE_NAME)
+
+
+    # Create the directory if it doesn't exist
+    os.makedirs(XDG_SCRIBE_DATA, exist_ok=True)
+    os.makedirs(XDG_APP_DATA, exist_ok=True)
+
+    # Copy your files to the desired location
+    print("Copying files to", XDG_SCRIBE_DATA)
+    shutil.copy('share/icon.jpg', XDG_SCRIBE_DATA)
+
+    with open('templates/scribe.desktop') as f:
+        template = f.read()
+
+    bin_folder = sysconfig.get_path("scripts")
+    desktop_file = template.format(XDG_SCRIBE_DATA=XDG_SCRIBE_DATA, bin_folder=bin_folder, options=' '.join(o.arguments))
+
+    print("Writing desktop file to", XDG_APP_DATA)
+    with open(os.path.join(XDG_APP_DATA, 'scribe.desktop'), "w") as f:
+        f.write(desktop_file)
+
+
+if __name__ == "__main__":
+    main()

scribe/keyboard.py

@@ -0,0 +1,19 @@
+"""This module handles typing characters as if they were typed on a keyboard.
+"""
+try:
+    # import pyautogui
+    from pynput.keyboard import Controller
+
+except ImportError:
+    print("Please install pynput to use the keyboard feature.")
+    print("Alternatively specify [keyboard] optional dependency to voskrealtime, e.g. `pip install -e .[keyboard]`")
+    raise
+
+# Create a keyboard controller
+keyboard = Controller()
+
+def type_text(text, interval=0):
+    # Simulate typing a string
+    # import subprocess
+    # subprocess.run(["ydotool", "type", text])
+    keyboard.type(text)

scribe/models.py

@@ -0,0 +1,133 @@
+import os
+import json
+import numpy as np
+from scribe.util import download_model
+
+VOSK_MODELS_FOLDER = os.path.join(os.environ.get("HOME"),
+                                      ".local/share/vosk/language-models")
+
+
+class AbstractTranscriber:
+    backend = None
+    def __init__(self, model, model_name=None, language=None, samplerate=16000, model_kwargs={}):
+        self.model_name = model_name
+        self.language = language
+        self.model = model
+        self.model_kwargs = model_kwargs
+        self.samplerate = samplerate
+
+    def transcribe_audio(self, audio_data):
+        raise NotImplementedError()
+
+    def transcribe_realtime_audio(self, audio_data):
+        raise NotImplementedError()
+
+    def start_recording(self, microphone,
+                        start_message="Recording... Press Ctrl+C to stop.",
+                        stop_message="Stopped recording."):
+
+        with microphone.open_stream():
+            print(start_message)
+
+            try:
+                while True:
+                    while not microphone.q.empty():
+                        data = microphone.q.get()
+                        yield self.transcribe_realtime_audio(data)
+
+            except KeyboardInterrupt:
+                pass
+
+            finally:
+                result = self.finalize()
+                microphone.q.queue.clear()
+                yield result
+
+            print(stop_message)
+
+
+def get_vosk_model(model, data_folder=None, url=None):
+    """Load the Vosk recognizer"""
+    import vosk
+    if data_folder is None:
+        data_folder = VOSK_MODELS_FOLDER
+    model_path = os.path.join(data_folder, model)
+    if not os.path.exists(model_path):
+        if url is None:
+            url = f"https://alphacephei.com/vosk/models/{model}.zip"
+        download_model(url, data_folder)
+        assert os.path.exists(model_path)
+
+    return vosk.Model(model_path)
+
+
+def get_vosk_recognizer(model, samplerate=16000):
+    import vosk
+    return vosk.KaldiRecognizer(model, samplerate)
+
+
+class VoskTranscriber(AbstractTranscriber):
+    backend = "vosk"
+
+    def __init__(self, model_name, model=None, model_kwargs={}, **kwargs):
+        if model is None:
+            model = get_vosk_model(model_name, **model_kwargs)
+        super().__init__(model, model_name, model_kwargs=model_kwargs, **kwargs)
+        self.recognizer = get_vosk_recognizer(model, self.samplerate)
+
+    def transcribe_realtime_audio(self, audio_bytes=b"", finalize=False):
+        final = self.recognizer.AcceptWaveform(audio_bytes)
+        if final:
+            result = self.recognizer.Result()
+        else:
+            result = self.recognizer.PartialResult()
+        result_dict = json.loads(result)
+
+        if final:
+            pass
+        elif finalize:
+            result_dict["text"] = result_dict.pop("partial", "")
+        else:
+            assert not final
+            if "text" in result_dict:
+                del result_dict["text"]
+        return result_dict
+
+    def transcribe_audio(self, audio_data=None):
+        return self.transcribe_realtime_audio(audio_data, finalize=True)
+
+    def finalize(self):
+        return self.transcribe_audio(b"")
+
+
+class WhisperTranscriber(AbstractTranscriber):
+    backend = "whisper"
+
+    def __init__(self, model_name, language=None, model=None, model_kwargs={}, **kwargs):
+        import whisper
+        if model is None:
+            model = whisper.load_model(model_name)
+        super().__init__(model, model_name, language, model_kwargs=model_kwargs, **kwargs)
+        self.audio_buffer = b''
+
+    def transcribe_realtime_audio(self, audio_bytes=b"", max_duration=60):
+        self.audio_buffer += audio_bytes
+
+        one_second = self.samplerate * 2 # 16-bit audio, 1 channel  ~ 32000 bytes
+        if len(self.audio_buffer) < max_duration * one_second:
+            return {"partial": f"{len(self.audio_buffer)} bytes received (duration: {len(self.audio_buffer) / one_second:.2f} seconds)"}
+
+        else:
+            return self.finalize()
+
+    def transcribe_audio(self, audio_bytes):
+        print("\nTranscribing...")
+        audio_array = np.frombuffer(audio_bytes, dtype=np.int16).flatten().astype(np.float32) / 32768.0
+        return self.model.transcribe(audio_array, fp16=False, language=self.language)
+
+    def finalize(self):
+        if len(self.audio_buffer) == 0:
+            return {"text": ""}
+        result = self.transcribe_audio(self.audio_buffer)
+        self.audio_buffer = b''
+        return result

scribe/models.toml

@@ -0,0 +1,31 @@
+[vosk.en]
+model = "vosk-model-en-us-0.42-gigaspeech"
+
+[vosk.fr]
+model = "vosk-model-fr-0.22"
+
+[vosk.de]
+model = "vosk-model-de-tuda-0.6-900k"
+
+[vosk.it]
+model = "vosk-model-it-0.22"
+
+[_meta.en]
+language = "English (US)"
+start_message = "Listening... Press Ctrl+C to stop."
+stop_message = "Recording stopped."
+
+[_meta.fr]
+language = "French"
+start_message = "En écoute... Appuyez sur Ctrl+C pour arrêter."
+stop_message = "Écoute arrêtée."
+
+[_meta.de]
+language = "German"
+start_message = "Hören... Drücken Sie Strg+C, um zu stoppen."
+stop_message = "Aufnahme gestoppt."
+
+[_meta.it]
+language = "Italian"
+start_message = "In ascolto... Premere Ctrl+C per interrompere."
+stop_message = "Registrazione interrotta."

scribe/saverecording.py

@@ -0,0 +1,62 @@
+import sounddevice as sd
+import time
+import numpy as np
+from pydub import AudioSegment
+import io
+
+# Set up the audio parameters
+samplerate = 16000  # Vosk models typically use 16 kHz
+channels = 1
+duration = 5  # in seconds
+chunk_size = 1024  # Number of samples per chunk (adjust this based on your needs)
+
+# Create a numpy array to store the full audio buffer
+full_audio = np.zeros((0,), dtype=np.float32)  # Use float32 initially for better precision
+
+# Callback function to collect audio data into the buffer
+def callback(indata, frames, time, status):
+    if status:
+        print(status)
+    global full_audio
+    # Append the incoming data to the full audio buffer (in float32)
+    full_audio = np.concatenate((full_audio, indata[:, 0]))
+
+# Function to record audio for a fixed duration
+def record_for_duration(duration):
+    try:
+        with sd.InputStream(samplerate=samplerate, channels=channels, callback=callback):
+            print(f"Recording for {duration} seconds or interrupt with Ctrl-C")
+            sd.sleep(duration * 1000)  # Sleep for the duration to ensure we record for the fixed time
+    except KeyboardInterrupt:
+        pass
+    print("Recording finished.")
+    save_audio_as_mp3()
+
+# Function to save the recorded audio as an MP3 file
+def save_audio_as_mp3():
+    # Convert the float32 audio buffer to 16-bit PCM (this is required for conversion to MP3)
+    audio_16bit = np.int16(full_audio * 32767)  # Scale to the 16-bit range
+    
+    # Create an in-memory audio file using io.BytesIO
+    audio_data = io.BytesIO()
+    
+    # Save the audio as WAV using pydub (since pydub works with WAV directly)
+    # Convert the numpy array to a pydub AudioSegment
+    audio_segment = AudioSegment(
+        audio_16bit.tobytes(),
+        frame_rate=samplerate,
+        sample_width=2,  # 16-bit audio
+        channels=1
+    )
+    
+    # Export as MP3`
+    audio_segment.export(audio_data, format="mp3")
+    
+    # Save to a file
+    with open("recording.mp3", "wb") as f:
+        f.write(audio_data.getvalue())
+    print("Recording saved as recording.mp3")
+
+# Example: record for 5 seconds
+record_for_duration(5*60)
+

scribe/streamer.py

@@ -0,0 +1,215 @@
+from pathlib import Path
+import tomllib
+import argparse
+from scribe.audio import Microphone
+from scribe.util import print_partial, clear_line, prompt_choices, check_dependencies, ansi_link, colored
+from scribe.models import VoskTranscriber, WhisperTranscriber
+
+with open(Path(__file__).parent / "models.toml", "rb") as f:
+    language_config_default = tomllib.load(f)
+
+language_config = language_config_default.copy()
+
+
+# Commencer l'enregistrement
+def start_recording(micro, transcriber, keyboard=False, latency=0):
+
+    if keyboard:
+        try:
+            from scribe.keyboard import type_text
+        except ImportError:
+            keyboard = False
+            exit(1)
+
+    greetings = { k: v for k, v in language_config["_meta"].get(transcriber.language, {}).items()
+                if v is not None and k.startswith(("start", "stop"))
+    }
+
+    for result in transcriber.start_recording(micro, **greetings):
+
+        if result.get('text'):
+            clear_line()
+            print(result.get('text'))
+            if keyboard:
+                type_text(result['text'] + " ", interval=latency) # Simulate typing
+        else:
+            print_partial(result.get('partial', ''))
+
+
+def get_default_backend():
+    try:
+        import vosk
+        return "vosk"
+    except ImportError:
+        try:
+            import whisper
+            return "whisper"
+        except ImportError:
+            raise ImportError("Please install either vosk or whisper to use this script.")
+
+BACKENDS = ["whisper", "vosk"]
+UNAVAILABLE_BACKENDS = []
+
+
+def pick_specialist_model(model, language, backend):
+    """ choose a specialist version of a model if language is specified (whisper)"""
+
+    if backend == "whisper" and language and language.lower() in ["en", "english"]:
+        available_models_en = ["tiny.en", "base.en", "small.en", "medium.en", "large", "turbo"]
+        if model + ".en" in available_models_en:
+            model += ".en"
+
+    return model
+
+
+def get_transcriber(o, prompt=True):
+
+    if o.backend:
+        checked_backend = check_dependencies(o.backend)
+        if not checked_backend:
+            print(f"Backend {o.backend} is not available.")
+            exit(1)
+        backend = o.backend
+
+    elif not prompt:
+        backend = choices[0]
+
+    else:
+        checked_backend = False
+        while not checked_backend:
+            backend = prompt_choices(BACKENDS, o.backend, "backend", UNAVAILABLE_BACKENDS)
+            # raise an error if the user has explicitly selected a backend that is not available
+            checked_backend = check_dependencies(backend, raise_error=backend==o.backend)
+            if not checked_backend:
+                print(f"Backend {o.backend} is not available.")
+                UNAVAILABLE_BACKENDS.append(backend)
+
+    print(f"Selected backend: {backend}")
+
+    if o.model:
+        model = pick_specialist_model(o.model, o.language, backend)
+
+    else:
+
+        if backend == "vosk":
+            available_languages = list(language_config[backend])
+            if o.language:
+                if o.language not in available_languages:
+                    print(f"Language '{o.language}' is not pre-defined (yet) for backend '{backend}'.")
+                    print(f"Yet it may actually exist.")
+                    print(f"Please choose the model explictly from {ansi_link('https://alphacephei.com/vosk/models')}.")
+                    print(f"Or pick one of the pre-defined languages: ", " ".join(available_languages))
+                    exit(1)
+                choices = [language_config[backend][o.language]["model"]]
+                default_model = choices[0]
+
+            else:
+                available_models = [language_config[backend][lang]["model"] for lang in available_languages]
+                choices = list(zip(available_models, available_languages)) + [f" * [Any model from {ansi_link('https://alphacephei.com/vosk/models')}]"]
+                default_model = choices[0]
+
+            print(f"For information about vosk models see: {ansi_link('https://alphacephei.com/vosk/models')}")
+            if prompt:
+                model = prompt_choices(choices, default=default_model, label="model")
+            else:
+                model = default_model
+
+        elif backend == "whisper":
+
+            models = ["tiny", "base", "small", "medium", "large", "turbo"]
+            english_models = ["tiny.en", "base.en", "small.en", "medium.en"]
+            default_model = "small"
+
+            print("Some models have a specialized English version (.en) which will be selected as default is `-l en` was requested, but can also be requested explicitly below (option not listed). See [documentation](https://github.com/openai/whisper?tab=readme-ov-file#available-models-and-languages).")
+            if prompt:
+                model = prompt_choices(models, default=default_model, label="model",
+                                        hidden_models=english_models)
+            else:
+                model = default_model
+
+            model = pick_specialist_model(model, o.language, backend)
+
+    print(f"Selected model: {model}")
+
+    if backend == "vosk":
+        try:
+            transcriber = VoskTranscriber(model_name=model,
+                                        language=o.language,
+                                        samplerate=o.samplerate,
+                                        model_kwargs={"data_folder": o.data_folder})
+        except Exception as error:
+            print(error)
+            print(f"Failed to (down)load model {model}.")
+            exit(1)
+
+    elif backend == "whisper":
+        transcriber = WhisperTranscriber(model_name=model, language=o.language, samplerate=o.samplerate)
+
+    else:
+        raise ValueError(f"Unknown backend: {backend}")
+
+    return transcriber
+
+def get_parser():
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--backend", choices=BACKENDS,
+                        help="Choose the backend to use for speech recognition (will be prompted otherwise).")
+
+    parser.add_argument("--model",
+                        help="""For vosk, any model from https://alphacephei.com/vosk/models,
+                        e.g. 'vosk-model-small-en-us-0.15'.
+                        For whisper, see https://github.com/openai/whisper?tab=readme-ov-file#available-models-and-languages""")
+
+    parser.add_argument("-l", "--language", choices=list(language_config["vosk"]),
+                        help="An alias for preselected models when using the vosk backend, or 'en' for the English version of whisper models.")
+
+    parser.add_argument("--no-prompt", action="store_false", dest="prompt", help="Disable prompts for backend and model selection and jump to recording")
+
+    parser.add_argument("--samplerate", default=16000, type=int, help=argparse.SUPPRESS)
+    parser.add_argument("--keyboard", action="store_true")
+    parser.add_argument("--latency", default=0, type=float, help="keyboard latency")
+
+    parser.add_argument("--data-folder", help="Folder to store Vosk models.")
+
+    return parser
+
+
+def main(args=None):
+
+    parser = get_parser()
+    o = parser.parse_args(args)
+
+
+    # Set up the microphone for recording
+    micro = Microphone(samplerate=o.samplerate)
+
+    transcriber = None
+
+    while True:
+        if transcriber is None:
+            transcriber = get_transcriber(o, prompt=o.prompt)
+        print(f"[ Model {transcriber.model_name} from {transcriber.backend} selected. ]")
+        if o.prompt:
+            print(f"Choose any of the following actions:")
+            print(f"[q] quit")
+            print(f"[e] change model")
+            print(colored(f"Press [Enter] or any other key to start recording.", "BOLD"))
+
+            key = input()
+            if key == "q":
+                exit(0)
+            if key == "e":
+                transcriber = None
+                continue
+        start_recording(micro, transcriber, keyboard=o.keyboard, latency=o.latency)
+
+        # if we arrived so far, that means we pressed Ctrl + C anyway, and need Enter to move on.
+        # So we leave the wider range of options to change the model.
+        o.prompt = True
+        o.backend = None
+        o.model = None
+        o.language = None
+
+if __name__ == "__main__":
+    main()

scribe/testpynput.py

@@ -0,0 +1,142 @@
+import subprocess
+
+def type_text(text):
+    subprocess.run(["ydotool", "type", text])
+
+# Example usage
+type_text("Hello, World!")
+
+
+import pyautogui
+import time
+
+# Simulate typing a string
+pyautogui.write('Hello, pyautogui!', interval=0.1)
+
+
+
+# # Simulate pressing and releasing the Enter key
+# pyautogui.press('enter')
+
+# # Simulate pressing and releasing the 'A' key
+# pyautogui.press('a')
+
+# # Simulate a hotkey combination (e.g., Ctrl+C)
+# pyautogui.hotkey('ctrl', 'c')
+
+# Hello, World!
+
+# # import os
+# # import subprocess
+# # from evdev import UInput, ecodes as e
+# # # Function to create and initialize a virtual keyboard
+# # def create_virtual_keyboard():
+# #     capabilities = {
+# #         e.EV_KEY: [e.KEY_A, e.KEY_B, e.KEY_C, e.KEY_1, e.KEY_2, e.KEY_3]
+# #     }
+# #     return UInput(capabilities)
+# # # Function to send a keystroke
+# # def send_keystroke(virtual_keyboard, key):
+# #     virtual_keyboard.write(e.EV_KEY, key, 1)  # Key down
+# #     virtual_keyboard.write(e.EV_KEY, key, 0)  # Key up
+# #     virtual_keyboard.syn()
+
+# # # Main script execution
+# # if __name__ == "__main__":
+# #     try:
+# #         vk = create_virtual_keyboard()
+# #         print("Virtual keyboard initialized.")
+# #         send_keystroke(vk, e.KEY_A)  # Sends the 'A' key
+# #         send_keystroke(vk, e.KEY_B)  # Sends the 'B' key
+# #     finally:
+# #         vk.close()
+# #         print("Virtual keyboard closed.")
+
+
+# import os
+# import subprocess
+# from evdev import UInput, ecodes as e
+
+# # Function to create and initialize a virtual keyboard
+# def create_virtual_keyboard():
+#     capabilities = {
+#         e.EV_KEY: [e.KEY_A, e.KEY_B, e.KEY_C, e.KEY_1, e.KEY_2, e.KEY_3]
+#     }
+#     try:
+#         ui = UInput(capabilities, name="virtual-keyboard")
+#         print("Virtual keyboard created successfully.")
+#         return ui
+#     except Exception as ex:
+#         print(f"Failed to create virtual keyboard: {ex}")
+#         return None
+
+# # Function to send a keystroke
+# def send_keystroke(virtual_keyboard, key):
+#     try:
+#         virtual_keyboard.write(e.EV_KEY, key, 1)  # Key down
+#         virtual_keyboard.write(e.EV_KEY, key, 0)  # Key up
+#         virtual_keyboard.syn()
+#         print(f"Sent keystroke: {key}")
+#     except Exception as ex:
+#         print(f"Failed to send keystroke: {ex}")
+
+# # Main script execution
+# if __name__ == "__main__":
+#     vk = create_virtual_keyboard()
+#     if vk:
+#         try:
+#             send_keystroke(vk, e.KEY_A)  # Sends the 'A' key
+#             send_keystroke(vk, e.KEY_B)  # Sends the 'B' key
+#         finally:
+#             vk.close()
+#             print("Virtual keyboard closed.")
+
+
+from pynput.keyboard import Controller, Key
+import time
+
+# Create a keyboard controller
+keyboard = Controller()
+
+# Simulate typing a string
+keyboard.type("Hello, World!")
+
+# Simulate pressing and releasing a key
+keyboard.press(Key.enter)
+keyboard.release(Key.enter)
+
+# Simulate pressing and releasing the 'A' key
+keyboard.press('a')
+keyboard.release('a')
+
+# Simulate pressing and releasing the 'Ctrl' key
+with keyboard.pressed(Key.ctrl):
+    keyboard.press('c')
+    keyboard.release('c')
+
+
+
+# import time
+# import subprocess
+
+# def send_key_event(event_device, key_code):
+#     # Press the key
+#     subprocess.run(["sudo", "evemu-event", event_device, "--type", "EV_KEY", "--code", key_code, "--value", "1", "--sync"])
+#     # Release the key
+#     subprocess.run(["sudo", "evemu-event", event_device, "--type", "EV_KEY", "--code", key_code, "--value", "0", "--sync"])
+
+# # Example usage
+# event_device = "/dev/input/event3"  # Your keyboard device
+# send_key_event(event_device, "KEY_A")
+
+# for letter in "Hello, World!":
+#     if letter:
+#         if letter == " ":
+#             send_key_event(event_device, "KEY_SPACE")
+#         elif letter == ",":
+#             send_key_event(event_device, "KEY_COMMA")
+#         elif letter == "!":
+#             send_key_event(event_device, "KEY_1")
+#         else:
+#             send_key_event(event_device, f"KEY_{letter.upper()}")
+#     time.sleep(0.1)

scribe/util.py

@@ -0,0 +1,185 @@
+import os
+import re
+import tqdm
+import shutil
+from functools import partial
+
+
+class bcolors:
+    # https://stackoverflow.com/a/287944/2192272
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+
+def strip_colors(s):
+    for name, c in vars(bcolors).items():
+        if name.startswith("_"):
+            continue
+        s = s.replace(c, '')
+    return s
+
+
+def ansi_link(uri, label=None):
+    """https://stackoverflow.com/a/71309268/2192272
+    """
+    if label is None:
+        label = uri
+    parameters = ''
+
+    # OSC 8 ; params ; URI ST <name> OSC 8 ;; ST
+    escape_mask = '\033]8;{};{}\033\\{}\033]8;;\033\\'
+
+    return escape_mask.format(parameters, uri, label)
+
+def colored(text, color):
+    if hasattr(bcolors, color):
+        color = getattr(bcolors, color)
+    return f"{color}{text}{bcolors.ENDC}"
+
+
+ANSI_LINK_RE = re.compile(r'(?P<ansi_sequence>\033]8;(?P<parameter>.*?);(?P<uri>.*?)\033\\(?P<label>.*?)\033]8;;\033\\)')
+
+def strip_ansi_link(s):
+    for m in ANSI_LINK_RE.findall(s):
+        s = s.replace(m[0], m[3])
+    return s
+
+
+def strip_all(s):
+    s = strip_colors(s)
+    s = strip_ansi_link(s)
+    return s
+
+
+# Function to clear the terminal line
+def clear_line():
+    # Get terminal width
+    terminal_width = shutil.get_terminal_size().columns
+    print("\r" + " " * terminal_width, end="")  # Clear the line
+    print("\r", end="")  # Return cursor to the beginning of the line
+
+
+def print_partial(msg):
+    # Get terminal width
+    terminal_width = shutil.get_terminal_size().columns
+    start = max(0, len(msg) + 7 - terminal_width)
+    print(f"\r[...] {msg[start:]}", end="")
+
+def check_status_code(status_code):
+    if 200 <= status_code < 300:
+        return True
+    else:
+        return False
+
+def download_model(url, data_folder):
+    import requests
+    import zipfile
+    import io
+
+    os.makedirs(data_folder, exist_ok=True)
+
+    print(f"Downloading model from {url}...")
+    response = requests.get(url, stream=True)
+
+    # check the URL was correct:
+    if not check_status_code(response.status_code):
+        raise RuntimeError(f"Model download failed with error {response.status_code}")
+
+    total_size = int(response.headers.get('content-length', 0))
+    block_size = 1024  # 1 Kibibyte
+    t = tqdm.tqdm(total=total_size, unit='iB', unit_scale=True)
+
+    with io.BytesIO() as temp_file:
+        for data in response.iter_content(block_size):
+            t.update(len(data))
+            temp_file.write(data)
+        t.close()
+        temp_file.seek(0)
+
+        # check the file was downloaded correctly
+        if total_size != 0 and t.n != total_size:
+            raise RuntimeError(f"Model download size is 0 or less than stated size")
+
+        with zipfile.ZipFile(temp_file) as z:
+            z.extractall(data_folder)
+
+    print(f"Model downloaded and unpacked to {data_folder}")
+
+
+def format_choice(enum, default=None, unavailable=None):
+    i, value = enum
+    if type(value) in [tuple, list]:
+        value_str = f" {value[0]} ({' | '.join(value[1:])})"
+    else:
+        value_str = value
+
+    if (default is not None and value == default) or (default is None and i == 0):
+        return f'  ' + colored(f'({i+1}) {value_str} [Press Enter]', 'BOLD')
+    elif unavailable and value in unavailable:
+        return f'  ' + colored(f'{" "} {value_str} -> unavailable !!', 'FAIL')
+    else:
+        return f'  ({i+1}) {value_str}'
+
+def is_integer(value):
+    try:
+        int(value)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+def prompt_choices(choices, default=None, label="value", unavailable_choices=None, hidden_models=None):
+    value = None
+    if unavailable_choices is None:
+        unavailable_choices = []
+        available_choices = choices
+    else:
+        available_choices = [c for c in choices if c not in unavailable_choices]
+
+    wildcard = any("*" in choice for choice in available_choices)
+
+    while (value not in (available_choices + (hidden_models or []))) or ("*" in value):
+        if value:
+            print(f"Invalid {label}: {value}")
+        value = input(f"""Please choose a {label}:
+{'\n'.join(map(partial(format_choice, default=default, unavailable=unavailable_choices),
+               enumerate(available_choices + unavailable_choices)))}
+(type number or any name or alias or press [Enter])...
+""")
+        if value == "":
+            value = default or available_choices[0]
+
+        if is_integer(value):
+            try:
+                value = available_choices[int(value) - 1]
+            except IndexError:
+                continue
+
+        if "*" in value:
+            continue
+
+        # can match any other choice so we break
+        if wildcard:
+            break
+
+    assert "*" not in value
+    return value[0] if type(value) in [list, tuple] else value
+
+
+def check_dependencies(backend, dependencies=None, raise_error=False):
+    from importlib import import_module
+    modules = dependencies or [backend]
+    try:
+        for module in modules:
+            import_module(module)
+        return True
+    except ImportError:
+        # if requested by the user, raise an Exception
+        if raise_error:
+            raise
+        return False
+    return False

scribe_cli-0.3.0.dist-info/LICENSE

@@ -0,0 +1,29 @@
+MIT License
+
+Copyright (c) 2024 Mahé Perrette
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Note: This project relies on external packages that may have more restrictive
+licenses. For example, the `pynput` package is licensed under LGPLv3, which
+has different requirements compared to the MIT License. Please review the
+licenses of all dependencies before using or distributing this software to
+ensure compliance with their respective terms.

scribe_cli-0.3.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.2
+Name: scribe-cli
+Version: 0.3.0
+Summary: scribe is a local speech recognition tool that provides real-time transcription using vosk and whisper AI.
+Author-email: Mahé Perrette <mahe.perrette@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Mahé Perrette
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+        ---
+        
+        Note: This project relies on external packages that may have more restrictive
+        licenses. For example, the `pynput` package is licensed under LGPLv3, which
+        has different requirements compared to the MIT License. Please review the
+        licenses of all dependencies before using or distributing this software to
+        ensure compliance with their respective terms.
+Project-URL: Homepage, https://github.com/perrette/scribe
+Keywords: speech recognition,transcription,AI,language,vosk,whisper,openai
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: sounddevice
+Requires-Dist: tqdm
+Requires-Dist: requests
+Provides-Extra: keyboard
+Requires-Dist: pynput; extra == "keyboard"
+Provides-Extra: whisper
+Requires-Dist: openai-whisper; extra == "whisper"
+Provides-Extra: vosk
+Requires-Dist: vosk; extra == "vosk"
+Provides-Extra: all
+Requires-Dist: pynput; extra == "all"
+Requires-Dist: openai-whisper; extra == "all"
+Requires-Dist: vosk; extra == "all"
+
+# Scribe
+
+`scribe` is a local speech recognition tool that provides real-time transcription using vosk and whisper AI.
+
+## Installation
+
+Install PortAudio library. E.g. on Ubuntu:
+
+```bash
+sudo apt-get install portaudio19-dev
+```
+
+The python dependencies should be dealt with automatically:
+
+```bash
+pip install scribe-cli[all]"
+```
+
+(note the `-cli` suffix for client)
+
+or for local development:
+
+```bash
+git clone https://github.com/perrette/scribe.git
+cd scribe
+pip install -e .[all]
+```
+
+You can leave the optional dependencies (leave out `[all]`) but must install at least one of `vosk` or `openai-whisper` packages (see Usage below).
+
+The `vosk` language models will download on-the-fly.
+The default data folder is `$HOME/.local/share/vosk/language-models`.
+This can be modified.
+
+
+## Usage
+
+Just type in the terminal:
+
+```bash
+scribe
+```
+and the script will guide you through the choice of backend (`whisper` or `vosk`) and the specific language model.
+After this, you will be prompted to start recording your microphone and print the transcribed text in real-time (`vosk`)
+or until after recording is complete (`whisper`).
+You can interrupt the recording via Ctrl + C and start again or change model.
+
+The default (`whisper`) is excellent at transcribing a full-length audio sequences in [many languages](https://github.com/openai/whisper?tab=readme-ov-file#available-models-and-languages). It is really impressive,
+but it cannot do real-time out of the box, and depending on the model can have relatively long execution time, especially with the `turbo` model (at least on my laptop with CPU only). The `small` model is also excellent and runs much faster. It is selected as default in `scribe` for that reason.
+With the `whisker` model you need to stop the registration manually before the transcription occurs (Ctrl + C), though after
+60 seconds it will stop automatically (and try to continue afterward).
+
+The `vosk` backend is good at
+doing real-time transcription for one language, but tended to make more mistakes in my tests and it does not do punctuation.
+There are many [vosk models](https://alphacephei.com/vosk/models) available, and here a few are associated to [a handful of languages](scribe/models.toml) `en`, `fr`, `it`, `de` (so far).
+
+To skip the initial selection menu you can do:
+```bash
+scribe --backend whisper --model small --no-prompt
+```
+where `--no-prompt` jumps right to the recording (after the first interruption, you can still choose to change the backend and model).
+
+### Advanced usage as keyboard replacement
+
+With the `--keyboard` option `scribe` will attempt to simulate a keyboard and send transcribed characters to the applcation under focus:
+
+```bash
+scribe --keyboard
+```
+
+It relies on the optional `pynput` dependency (installed together with `scribe` if you used the `[all]` or `[keyboard]` option).
+
+`pynput` may require [some configuration](https://pynput.readthedocs.io/en/latest/limitations.html) (I *think* got it to work with `xhost +SI:localuser:$(whoami)` as far as the display is concerned). It has [limitations]((https://pynput.readthedocs.io/en/latest/limitations.html)). In my Ubuntu + Wayland system it works in chromium based applications (including vscode) but it does not in firefox and sublime text and any of the rest (not even in a terminal !).
+Workarounds include using the Xorg version of GNOME... Suggestions welcome.
+
+### Start as an application in Ubuntu
+
+If you run Ubuntu (or else?) with GNOME, the script `scribe-install [...]` will create a `scribe.desktop` file and place it under `$HOME/.local/share/applications`
+to make it available from the quick launch menu. Any option will be passed on to `scribe`.

scribe_cli-0.3.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+scribe/__init__.py,sha256=WjDmvecyDIyJLYp4rCV9vsSYbQDc4L1EpYqORvEXliI,33
+scribe/_version.py,sha256=Jk2iAU7m-7Vx9XV1TtdD9ZoJraIncDq_4_Wd-qtUotg,411
+scribe/audio.py,sha256=PXtkRwVlyEf-m3eVIH61nlCpfiiZvFVJQWdW4mhL6bY,1716
+scribe/install_desktop.py,sha256=iKZjIddi_Y-xmg-mrrdZvwrec4gwS2TiNvdg1Uu2YqQ,1491
+scribe/keyboard.py,sha256=jhiPv927Pydnta1Q8QaoPWNCQpojDZmvuAZ8UOo1TyM,581
+scribe/models.py,sha256=bJVp_2t_UG996NBWh2bQf5_44ny4Mqr-6kCyS0w7qNA,4466
+scribe/models.toml,sha256=H5IvYx03QbaZpgPuyl08RC_t24FqN-ZKfS5bnCMVLSc,715
+scribe/saverecording.py,sha256=20QyJNMb1kzGkLXajBnBxIXMMji0Bp3Do69bHZD8S7g,2137
+scribe/streamer.py,sha256=-4hWI6lX3Kz1qvc8NSqtofIlOkOVN2mS-JqCC4eHCzg,8223
+scribe/testpynput.py,sha256=J1GlX7ns2yMeEfhoq_BVKHQ6REcTKhS8OMt2aak1RfY,4062
+scribe/util.py,sha256=ep-5W99tMltG4SAbdCMIB3qI98zVyb3M170OOlSXR_c,5322
+scribe_cli-0.3.0.dist-info/LICENSE,sha256=76NFkiJg6-f0qj4s4YSIkHcWho3eckzmOKIbEFMOM-U,1426
+scribe_cli-0.3.0.dist-info/METADATA,sha256=y3PMQDX44HnAKEAcFjpOTsr8zUbgkXfsegMuvmAjk1Y,6316
+scribe_cli-0.3.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+scribe_cli-0.3.0.dist-info/entry_points.txt,sha256=I76vox2zTEO8vr5b1UU6bYfKCjkviEyXMq4cndW8yQc,93
+scribe_cli-0.3.0.dist-info/top_level.txt,sha256=N57j6gzwa6unDew22CFvM3KKQQL0H2itDsc166HHINg,7
+scribe_cli-0.3.0.dist-info/RECORD,,

scribe_cli-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

scribe_cli-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+scribe = scribe.streamer:main
+scribe-install = scribe.install_desktop:main

scribe_cli-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+scribe