tranquillity 0.1.0__tar.gz

tranquillity-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: tranquillity
+Version: 0.1.0
+Provides-Extra: app
+Requires-Dist: opencv-contrib-python; extra == "app"
+Requires-Dist: requests; extra == "app"
+Requires-Dist: ollama; extra == "app"
+Requires-Dist: piper-tts; extra == "app"
+Requires-Dist: vosk; extra == "app"
+Requires-Dist: rapidfuzz; extra == "app"
+Requires-Dist: sounddevice; extra == "app"
+Requires-Dist: pyyaml; extra == "app"
+Requires-Dist: spacy; extra == "app"
+Requires-Dist: rich; extra == "app"
+Requires-Dist: python-dotenv; extra == "app"
+Requires-Dist: click; extra == "app"
+Requires-Dist: google-generativeai; extra == "app"
+Requires-Dist: google-genai; extra == "app"
+Requires-Dist: google-api-python-client; extra == "app"
+Requires-Dist: google-auth-httplib2; extra == "app"
+Requires-Dist: google-auth-oauthlib; extra == "app"
+Requires-Dist: html2text; extra == "app"
+Requires-Dist: feedparser; extra == "app"

tranquillity-0.1.0/README.md

@@ -0,0 +1,91 @@
+# Tranquillity
+
+What is Tranquillity?
+
+Tranquillity is a project that aims to recreate a personal assistant with GLaDOS AI voice, capable of assisting with any task on a PC.
+
+Inspired by the famous AI from the video game Portal 2, as well as projects already created throughout the Internet.
+
+<img src="https://github.com/user-attachments/assets/1f69f6fd-e8fd-4431-956d-32d97b91bb56" 
+        alt="Picture" 
+        width="800" 
+        height="600" 
+        style="display: block; margin: 10" />
+
+***
+
+Features:
+
+* **Personal AI Assistant** with GLaDOS voice synthesis (TTS).
+* **Voice Recognition** - French language support with rapid command parsing.
+* **Music Control** - Spotify integration (pause, resume, device management).
+* **Lighting Control** - Smart light management.
+* **Discord Integration** - Send messages to Discord directly from commands.
+* **ctOS CLI** - Custom command-line interface created specifically for Tranquillity.
+* **Voice-to-Voice LLM** - Direct voice conversation with AI processing.
+
+***
+
+Planned Features:
+
+* Enhanced gesture recognition and commands.
+* Extended camera vision capabilities.
+* Additional smart home integrations.
+* More language support.
+* And much more.
+
+***
+
+Development / Usage:
+
+For Linux or Windows:
+
+```bash
+./env/bin/python -m pip install -r requirement.txt
+```
+
+For NixOS:
+
+Requires devenv
+
+```bash
+devenv init
+```
+
+then
+
+```bash
+devenv start
+```
+
+Usage:
+
+```bash
+python ctOS.py --init
+python ctOS.py --start
+```
+
+Docker:
+
+```bash
+docker build -f docker/Dockerfile -t tranquillity:local .
+TRANQUILLITY_IMAGE=tranquillity:local python docker_launcher.py --help
+
+```
+
+The `tranquillity` command from `pyproject.toml` runs `docker_launcher.py` on the host. The Docker image itself runs `ctOS.py` and forwards the arguments supplied to the launcher.
+
+***
+
+Inspiration:
+
+This project wouldn't exist without inspiration and help.
+The project is primarily educational, and here are the repositories that helped me:
+
+* https://github.com/dnhkng/GLaDOS
+
+***
+
+I welcome any help!
+
+

tranquillity-0.1.0/ctOS.py

@@ -0,0 +1,43 @@
+from src.ctOS.start.init import demo
+from src.ctOS.start.start import start
+from src.ctOS.help import help
+import sys
+import asyncio
+from src.subsystem.notification_system import send_discord_message
+from dotenv import load_dotenv
+from src.tranquillity import init as tranquillity
+from src.ctOS.music.music import music_command
+from src.ctOS.music.init_token import init
+load_dotenv()
+
+def main():
+    nb = len(sys.argv)
+    
+    if nb <= 1:
+        help()
+        return
+    if sys.argv[1] == "--demo":
+        demo()
+        start()
+        return
+    if sys.argv[1] == "--music":
+        music_command()
+        return
+    if sys.argv[1] == "--send":
+        if sys.argv[2] == None:
+            return 84
+        asyncio.run(send_discord_message(sys.argv[2]))
+        return
+    if sys.argv[1] == "--init":
+        init()
+        return
+    if sys.argv[1] == "--start":
+        tranquillity()
+        return
+    if sys.argv[1] == "--help" or "-h":
+        help()
+    else:
+        return 84
+
+if __name__ == "__main__":
+    main()

tranquillity-0.1.0/docker_launcher.py

@@ -0,0 +1,37 @@
+import os
+import shutil
+import subprocess
+import sys
+
+
+IMAGE_ENV = "TRANQUILLITY_IMAGE"
+
+
+def main() -> int:
+    image = os.environ.get(IMAGE_ENV)
+    if not image:
+        print(
+            f"{IMAGE_ENV} n'est pas defini. Exemple: "
+            "export TRANQUILLITY_IMAGE=ghcr.io/mon-compte/tranquillity:latest",
+            file=sys.stderr,
+        )
+        return 2
+
+    if shutil.which("docker") is None:
+        print("Docker est requis mais la commande docker est introuvable.", file=sys.stderr)
+        return 127
+
+    try:
+        subprocess.run(["docker", "info"], check=True)
+        subprocess.run(["docker", "pull", image], check=True)
+        return subprocess.run(
+            ["docker", "run", "--rm", "-it", "--name", "tranquillity", image, *sys.argv[1:]]
+        ).returncode
+    except subprocess.CalledProcessError as error:
+        return error.returncode
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tranquillity-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tranquillity"
+version = "0.1.0"
+dependencies = []
+
+[project.optional-dependencies]
+app = [
+    "opencv-contrib-python",
+    "requests",
+    "ollama",
+    "piper-tts",
+    "vosk",
+    "rapidfuzz",
+    "sounddevice",
+    "pyyaml",
+    "spacy",
+    "rich",
+    "python-dotenv",
+    "click",
+    "google-generativeai",
+    "google-genai",
+    "google-api-python-client",
+    "google-auth-httplib2",
+    "google-auth-oauthlib",
+    "html2text",
+    "feedparser",
+]
+
+[project.scripts]
+tranquillity = "docker_launcher:main"
+
+[tool.setuptools]
+py-modules = ["ctOS", "docker_launcher"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["src*", "settings*"]
+namespaces = true

tranquillity-0.1.0/settings/settings.py

@@ -0,0 +1,5 @@
+IA_NAME = "gemini-3.5-flash-lite"
+VOICE_PATH = "model/tts/glados/fr_FR-glados-medium.onnx"
+MODEL_PATH = "model/vosk/vosk-model-small-fr/vosk-model-fr-0.22"
+SAMPLE_RATE = 16000
+BLOCK_SIZE = 4000

tranquillity-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tranquillity-0.1.0/src/core/gemini.py

@@ -0,0 +1,244 @@
+import os
+import sys
+import sounddevice as sd
+import queue
+import subprocess
+import tempfile
+import wave
+import threading
+import shlex
+from piper import PiperVoice
+from settings.settings import IA_NAME, VOICE_PATH, MODEL_PATH, SAMPLE_RATE, BLOCK_SIZE
+from dotenv import load_dotenv
+import re
+from vosk import Model, KaldiRecognizer, SetLogLevel
+import json
+import requests
+from src.subsystem.search_web import search_web
+from src.subsystem.get_email import get_email
+from google import genai
+from google.genai import types
+from src.subsystem.create_event import create_event
+from src.subsystem.list_event import list_calendar
+
+load_dotenv()
+
+recording_enabled = True
+audio_queue = queue.Queue()
+
+def callback(indata, frames, time, status):
+    global recording_enabled
+    if status:
+        print(status, file=sys.stderr)
+    if recording_enabled:
+        audio_queue.put(bytes(indata))
+
+
+def clean_for_tts(text: str) -> str:
+    text = re.sub(r'\*\*(.+?)\*\*', r'\1', text)
+    text = re.sub(r'\*(.+?)\*', r'\1', text)
+    text = re.sub(r'[*#`_]', '', text)
+    return text
+
+def player_worker(q: "queue.Queue[str | None]"):
+    global recording_enabled
+    while True:
+        path = q.get()
+        if path is None:
+            return
+        recording_enabled = False
+        subprocess.run(["mpv", "--no-terminal", "--really-quiet", path])
+        recording_enabled = True
+        try:
+            os.remove(path)
+        except OSError:
+            pass
+
+
+def clear_screen():
+    os.system('cls' if os.name == 'nt' else 'clear')
+
+def get_api_key():
+    api_key = os.getenv("GEMINI_API_KEY")
+    if api_key:
+        return api_key
+    
+    print("=== Configuration de la clé API Gemini ===")
+    print("Vous pouvez également définir la variable d'environnement GEMINI_API_KEY pour éviter cette étape.\n")
+    while True:
+        api_key = input("Veuillez entrer votre clé API Google Gemini : ").strip()
+        if api_key:
+            return api_key
+        print("La clé ne peut pas être vide. Veuillez réessayer.")
+
+
+def tts_worker(text_q, out_q, voice):
+    while True:
+        fragment = text_q.get()
+        if fragment is None:
+            out_q.put(None)
+            return
+        fd, path = tempfile.mkstemp(prefix="tts_", suffix=".wav")
+        os.close(fd)
+        with wave.open(path, "wb") as wav_file:
+            voice.synthesize_wav(fragment, wav_file)
+        out_q.put(path)
+
+def detect_command(response_text):
+    resultat = re.search(r"(?mi)^command:\s*(.+)$", response_text)
+
+    if resultat:
+        commande = resultat.group(1).strip()
+        return resultat.start(), commande
+    return None
+
+def execute_command(commande_raw):
+    if commande_raw:
+        try:
+            try:
+                args = shlex.split(commande_raw)
+                subprocess.run(args, shell=False)
+            except ValueError:
+                subprocess.run(commande_raw, shell=True)
+        except Exception as e:
+            pass
+    
+def gemini():
+    clear_screen()
+    print("Initialisation Tranquillity")
+    
+    api_key = get_api_key()
+    model_name = IA_NAME
+    
+    print("Initialisation de la personalité")
+
+    with open("settings/personality.txt", "r", encoding="utf-8") as f:
+        content = f.read()
+    system_instruction = content 
+    if not system_instruction:
+        system_instruction = "Tu es un assistant virtuel utile, amical et précis. Réponds toujours en français."
+        print(f"-> Contexte par défaut appliqué : \"{system_instruction}\"")
+    else:
+        print(f"-> Contexte personnalisé appliqué avec succès !")
+
+    print("\nInitialisation du modèle...")
+
+    client = genai.Client(api_key=api_key)
+
+    try:
+        chat = client.chats.create(
+            model=model_name,
+            config=types.GenerateContentConfig(
+                system_instruction=system_instruction,
+                tools=[search_web, get_email, list_calendar, create_event]
+            ),
+            history=[]
+        )
+    except Exception as e:
+        print(f"Erreur lors de l'initialisation du modèle : {e}")
+        sys.exit(1)
+
+    voice = PiperVoice.load(VOICE_PATH)
+    print("voice init success")
+
+    print("Initialisation VOSK")
+    print("VOSK load")
+    SetLogLevel(-1)
+
+    model = Model(MODEL_PATH)
+    rec = KaldiRecognizer(model, SAMPLE_RATE)
+
+    clear_screen()
+    print("==================================================")
+    print("             💬 CHAT INITIALISÉ AVEC SUCCÈS        ")
+    print("==================================================")
+    print(f"Modèle utilisé  : {model_name}")
+    print("--------------------------------------------------")
+    print("Instructions :")
+    print(" - Tapez votre message et appuyez sur Entrée.")
+    print(" - Écrivez 'exit', 'quit' ou 'quitter' pour fermer le chat.")
+    print(" - Écrivez 'clear' pour vider l'écran du terminal.")
+    print("==================================================\n")
+
+    audio_q: "queue.Queue[str | None]" = queue.Queue()
+    tts_text_q: "queue.Queue[str | None]" = queue.Queue()
+
+    t_tts = threading.Thread(target=tts_worker, args=(tts_text_q, audio_q, voice), daemon=True)
+    t_tts.start()
+    t = threading.Thread(target=player_worker, args=(audio_q,), daemon=True)
+    t.start()
+
+    one_use = False
+    print("En écoute...")
+    with sd.RawInputStream(
+            samplerate=SAMPLE_RATE,
+            blocksize=BLOCK_SIZE,
+            dtype="int16",
+            channels=1,
+            callback=callback,
+    ):
+        while True:
+            try:
+                data = audio_queue.get()
+                audio_q: "queue.Queue[str | None]" = queue.Queue()
+                if rec.AcceptWaveform(data) and one_use == False:
+                    one_use = True
+                    result = json.loads(rec.Result())
+                    user_input = result.get("text", "").strip()
+                    if not user_input:
+                        one_use = False
+                        continue
+                    if user_input.lower() in ['exit', 'quit', 'quitter']:
+                        print("\n Assistant : Au revoir ! Passez une excellente journée.")
+                        break
+                        
+                    if user_input.lower() == 'clear':
+                        clear_screen()
+                        print("==================================================")
+                        print("             CONVERSATION EN COURS             ")
+                        print("================================================--\n")
+                        one_use = False
+                        continue
+
+                    print("Vous", user_input)
+                    print(" Assistant : ", end="", flush=True)
+                    response = chat.send_message(user_input)
+
+                    streamed_text = response.text
+                    print(streamed_text, flush=True)
+
+                    command_start = None
+                    command_match = detect_command(streamed_text)
+                    if command_match:
+                        command_start, _ = command_match
+                        spoken_text = streamed_text[:command_start]
+                    else:
+                        spoken_text = streamed_text
+
+                    clean_tts = clean_for_tts(spoken_text)
+                    if clean_tts.strip():
+                        tts_text_q.put(clean_tts)
+
+                    print("\n")
+
+                    if command_start is not None:
+                        _, commande = detect_command(streamed_text)
+                        if commande:
+                            print(f"Commande détectée : {commande}")
+                            run_command = threading.Thread(target=execute_command, args=(commande,), daemon=True)
+                            run_command.start()
+                    one_use = False
+                    
+            except KeyboardInterrupt:
+                print("\n\n Assistant : Chat interrompu. Au revoir !")
+                audio_q.put(None)
+                t.join()
+                break
+            except Exception as e:
+                print(f"\nUne erreur est survenue lors de la communication avec l'API : {e}\n")
+                audio_q.put(None)
+                t.join()
+                break
+
+if __name__ == "__main__":
+    gemini()

tranquillity-0.1.0/src/ctOS/help.py

@@ -0,0 +1,21 @@
+def help():
+    print("==================================================")
+    print("         Bienvenue dans ctOS - CLI Tranquillity")
+    print("==================================================\n")
+    print("USAGE :")
+    print("  ctOS [commande]")
+    print("  ctOS [option]\n")
+    print("COMMANDES PRINCIPALES :\n")
+    print("  --start              Lance le programme principal Tranquillity")
+    print("GESTION MUSICALE :\n")
+    print("  --music pause        Met en pause la musique en cours")
+    print("  --music resume       Reprend la musique en pause")
+    print("  --music device       Affiche et gere les appareils audio connectes\n")
+    print("CONTROLE DOMOTIQUE :\n")
+    print("  --light toggle       Active/desactive les lumieres connectees\n")
+    print("OUTILS ET CONFIGURATION :\n")
+    print("  --init               Initialise le token Spotify et vérification")
+    print("  --send [message]     Envoie un message via Discord\n")
+    print("AUTRES :\n")
+    print("  --help, -h           Affiche ce message d'aide\n")
+    print("==================================================\n")

tranquillity-0.1.0/src/ctOS/light/light.py

@@ -0,0 +1,15 @@
+import os
+import sys
+from src.ctOS.light.toggle_light import toggle_light
+
+def light_command():
+    nb  = len(sys.argv)
+
+    if nb <= 2:
+        print("no argument give. Please give word")
+        return
+    if sys.argv[2] == "toggle":
+        toggle_light()
+        return
+    else:
+        print("no argument give. Please give word")

tranquillity-0.1.0/src/ctOS/light/toggle_light.py

@@ -0,0 +1,18 @@
+import os
+import subprocess
+
+FIFO_PATH = "/tmp/kitty_shell_input"
+CMD_LIGHT = "./ecc-api --toggle"
+
+def toggle_light():
+    if not os.path.exists(FIFO_PATH):
+        print(f"Sub-Agent: FIFO introuvable: {FIFO_PATH}")
+        return
+    with open(FIFO_PATH, "w") as fifo:
+        fifo.write(CMD_LIGHT + "\n")
+    subprocess.run(CMD_LIGHT)
+    return
+
+def toggle_light():
+    subprocess.run(CMD_LIGHT)
+    return

tranquillity-0.1.0/src/ctOS/music/get_id_device.py

@@ -0,0 +1,17 @@
+import requests
+import json
+import sys
+from src.ctOS.music.get_token_tmp import get_token
+import requests
+
+def get_id_device():
+    access_token = get_token()
+    url = "https://api.spotify.com/v1/me/player/devices"
+    header = {"Authorization": "Bearer " + access_token}
+
+    result = requests.get(url, headers=header)
+    try:
+        body = result.json()
+    except Exception:
+        body = result.text
+    print(body)

tranquillity-0.1.0/src/ctOS/music/get_token_tmp.py

@@ -0,0 +1,115 @@
+import os
+import json
+import base64
+import webbrowser
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlencode, urlparse, parse_qs
+from requests import post
+from dotenv import load_dotenv
+
+load_dotenv()
+
+CLIENT_ID = os.getenv("TOKEN_PUBLIC")
+CLIENT_SECRET = os.getenv("TOKEN_PRIVATE")
+REDIRECT_URI = "http://127.0.0.1:8888/callback"
+SCOPES = "user-read-playback-state user-modify-playback-state"
+TOKEN_FILE = os.path.join(os.path.dirname(__file__), ".spotify_token.json")
+
+
+def _basic_auth_header():
+    auth_string = f"{CLIENT_ID}:{CLIENT_SECRET}".encode("utf-8")
+    return "Basic " + base64.b64encode(auth_string).decode("utf-8")
+
+
+class _CallbackHandler(BaseHTTPRequestHandler):
+    code = None
+
+    def do_GET(self):
+        query = parse_qs(urlparse(self.path).query)
+        _CallbackHandler.code = query.get("code", [None])[0]
+        self.send_response(200)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        self.wfile.write(b"<h1>You can close this.</h1>")
+
+    def log_message(self, format, *args):
+        pass 
+
+
+def _request_authorization_code():
+    params = {
+        "client_id": CLIENT_ID,
+        "response_type": "code",
+        "redirect_uri": REDIRECT_URI,
+        "scope": SCOPES,
+    }
+    auth_url = "https://accounts.spotify.com/authorize?" + urlencode(params)
+    webbrowser.open(auth_url)
+
+    server = HTTPServer(("127.0.0.1", 8888), _CallbackHandler)
+    server.handle_request()
+    return _CallbackHandler.code
+
+
+def _exchange_code_for_tokens(code):
+    url = "https://accounts.spotify.com/api/token"
+    headers = {
+        "Authorization": _basic_auth_header(),
+        "Content-Type": "application/x-www-form-urlencoded",
+    }
+    data = {
+        "grant_type": "authorization_code",
+        "code": code,
+        "redirect_uri": REDIRECT_URI,
+    }
+    result = post(url, headers=headers, data=data)
+    result.raise_for_status()
+    return result.json()
+
+
+def _refresh_access_token(refresh_token):
+    url = "https://accounts.spotify.com/api/token"
+    headers = {
+        "Authorization": _basic_auth_header(),
+        "Content-Type": "application/x-www-form-urlencoded",
+    }
+    data = {
+        "grant_type": "refresh_token",
+        "refresh_token": refresh_token,
+    }
+    result = post(url, headers=headers, data=data)
+    result.raise_for_status()
+    return result.json()
+
+
+def _save_tokens(tokens):
+    with open(TOKEN_FILE, "w") as f:
+        json.dump(tokens, f)
+
+
+def _load_tokens():
+    if not os.path.exists(TOKEN_FILE):
+        return None
+    with open(TOKEN_FILE) as f:
+        return json.load(f)
+
+
+def get_token():
+    if not CLIENT_ID or not CLIENT_SECRET:
+        raise RuntimeError("TOKEN_PUBLIC et TOKEN_PRIVATE doivent etre definis dans l'environnement")
+
+    tokens = _load_tokens()
+
+    if tokens and "refresh_token" in tokens:
+        new_tokens = _refresh_access_token(tokens["refresh_token"])
+        new_tokens.setdefault("refresh_token", tokens["refresh_token"])
+        _save_tokens(new_tokens)
+        return new_tokens["access_token"]
+
+    code = _request_authorization_code()
+    if not code:
+        raise RuntimeError("Aucun code recu, autorisation echouee")
+
+    tokens = _exchange_code_for_tokens(code)
+    _save_tokens(tokens)
+    return tokens["access_token"]