tranquillity 0.1.0__py3-none-any.whl

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()

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())

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

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()

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")

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")

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

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)

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"]

src/ctOS/music/init_token.py

@@ -0,0 +1,34 @@
+import os
+from pathlib import Path
+from src.ctOS.music.get_token_tmp import get_token
+import time
+
+PATH_TOKEN = "src/music/.spotify_token.json"
+
+def init():
+    p = Path(".env")
+    if not p.exists():
+        print("Pas de .env detecter. Veuillez en créer un")
+        return 84
+    
+    token_public = os.getenv("TOKEN_PUBLIC")
+    token_private = os.getenv("TOKEN_PRIVATE")
+    if not token_public or not token_private:
+        print("Pas de token detecter. Veuillez vous referer a la doc pour pouvoir en obtenir")
+        time.sleep(2)
+        return 84
+
+    p = Path(PATH_TOKEN)
+    if not p.exists():
+        print("Premier utilisation detecter. Redirection vers la connection spotify")
+        time.sleep(2)
+        get_token()
+
+    token_discord = os.getenv("API_KEY")
+    if not token_discord:
+        print("Pas de Clef API pour connecter Tranquility au bot discord. Si vous souhaitez l'utiliser inscrivez vous au bot discord et mettez la clef api dans le .env")
+    else:
+        print("Clef API est détécter. L'integration discord est donc disponible.")
+        time.sleep(2)
+    print("Tous est désormais initialisé. Veuillez faire ctOS --start")
+    time.sleep(2)

src/ctOS/music/music.py

@@ -0,0 +1,26 @@
+import requests
+import json
+import sys
+from src.ctOS.music.get_token_tmp import get_token
+import requests
+from src.ctOS.music.get_id_device import get_id_device
+from src.ctOS.music.pause import pause
+from src.ctOS.music.resume import resume
+
+def music_command():
+    nb  = len(sys.argv)
+
+    if nb <= 2:
+        print("no argument give. Please give word")
+        return
+    if sys.argv[2] == "device":
+        get_id_device()
+        return
+    if sys.argv[2] == "pause":
+        pause()
+        return
+    if sys.argv[2] == "resume":
+        resume()
+        return
+    else:
+        print("no argument give. Please give word")

src/ctOS/music/pause.py

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

src/ctOS/music/resume.py

@@ -0,0 +1,15 @@
+import requests
+from src.ctOS.music.get_token_tmp import get_token
+
+def resume():
+    access_token = get_token()
+    url = "https://api.spotify.com/v1/me/player/play"
+    header = {"Authorization": "Bearer " + access_token, "Content-Type": "application/json"}
+    data = {}
+    result = requests.put(url, headers=header, json=data)
+    try:
+        body = result.json()
+    except Exception:
+        body = result.text
+    print(body)
+    print(result.status_code)

src/ctOS/start/init.py

@@ -0,0 +1,125 @@
+import time
+import random
+from collections import deque
+from rich.console import Console
+from rich.layout import Layout
+from rich.live import Live
+from rich.text import Text
+from rich.align import Align
+from rich.panel import Panel
+from pathlib import Path
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+console = Console()
+GREEN = "bold spring_green2"
+DIM_GREEN = "spring_green4"
+
+BOOT_LINES = [
+    "[INIT] Check env is created",
+    "[OK  ] Env check",
+    "[INIT] Check env variable",
+    "[OK  ] Variable good",
+    "[INIT] Check spotify section",
+    "[OK  ] Token is good",
+    "[INIT] Check other command",
+    "[OK  ] Other command good",
+    "[INIT] Start cli...",
+]
+
+SPACE_LINE = [
+    " "
+]
+
+WAITING_LINE = [
+    "."
+    ".."
+    "..."
+]
+
+START_LINE = [
+    "Hello from ctOS"
+]
+
+ERROR_LINE = "Error detected. First time to use ? Use ctOS --init"
+
+def make_layout() -> Layout:
+    layout = Layout()
+    layout.split_column(
+        Layout(name="main", ratio=2),
+        Layout(name="bottom", size=9),
+    )
+    layout["bottom"].split_row(
+        Layout(name="bottom_left"),
+    )
+    return layout
+
+def render_center(percent: int, width: int = 40) -> Align:
+    filled = int(width * percent / 100)
+    empty = width - filled
+    bar_str = "█" * filled + "░" * empty
+    text = Text(f"{bar_str} {percent:3d}%", style=GREEN, justify="center")
+    return Align.center(text, vertical="middle")
+
+def render_status(history: deque) -> Panel:
+    body = Text("\n".join(history), style=DIM_GREEN)
+    return Panel(body, border_style=DIM_GREEN)
+
+def check_file_env():
+    p = Path(".env")
+    if p.exists():
+        return 0
+    else:
+        return 84
+
+def check_token():
+    p = Path("src/music/.spotify_token.json")
+    if p.exists():
+        return 0
+    else:
+        return 84
+
+def check_variable():
+    token_public = os.getenv("TOKEN_PUBLIC")
+    token_private = os.getenv("TOKEN_PRIVATE")
+    if not token_public or not token_private:
+        return 84
+    else:
+        return 0
+
+STEPS = [
+    ("[INIT] Check env is created",     None),
+    ("[OK  ] Env check",                check_file_env),
+    ("[INIT] Check env variable",       None),
+    ("[OK  ] Variable good",            check_variable),
+    ("[INIT] Check spotify section",    None),
+    ("[OK  ] Token is good",            check_token),
+    ("[INIT] Check other command",      None),
+    ("[OK  ] Other command good",       None),
+    ("[INIT] Start cli...",             None),
+]
+
+def demo():
+    layout = make_layout()
+    history = deque(maxlen=6)
+
+    with Live(layout, console=console, refresh_per_second=20, screen=True):
+        for i, (label, check) in enumerate(STEPS):
+            history.append(label)
+
+            if check is not None:
+                r = check()
+                if r == 84:
+                    history.append(ERROR_LINE)
+                    time.sleep(2)
+                    return 84
+
+            percent = ((i + 1) * 100) // len(STEPS)
+            layout["main"].update(render_center(percent))
+            layout["bottom_left"].update(render_status(history))
+            time.sleep(1)
+
+if __name__ == "__main__":
+    demo()

src/ctOS/start/start.py

@@ -0,0 +1,61 @@
+
+import requests
+import time
+import random
+from collections import deque
+from rich.console import Console
+from rich.layout import Layout
+from rich.live import Live
+from rich.text import Text
+from rich.align import Align
+from rich.panel import Panel
+
+console = Console()
+GREEN = "bold spring_green2"
+DIM_GREEN = "spring_green4"
+
+BOOT_LINES = [
+    "[INIT] Loading all module...",
+    "[NET ] Establishing uplink to backbone...",
+    "[OK  ] All systems are onlines.",
+]
+
+SPACE_LINE = [
+    " "
+]
+
+WAITING_LINE = [
+    "."
+    ".."
+    "..."
+]
+
+START_LINE = [
+    "Hello from ctOS"
+]
+
+def make_layout() -> Layout:
+    layout = Layout()
+    layout.split_column(
+        Layout(name="main", ratio=2),
+    )
+    return layout
+
+def render_status(history: deque) -> Panel:
+    body = Text("\n".join(history), style=DIM_GREEN)
+    return Panel(body, border_style=DIM_GREEN)
+
+def start():
+    layout = make_layout()
+    history = deque(maxlen=6)
+    messages = BOOT_LINES
+    start = START_LINE
+    wait = WAITING_LINE
+    is_finish = False
+
+    with Live(layout, console=console, refresh_per_second=20, screen=True):
+        while is_finish is False:
+            history = None
+            history = deque(maxlen=6)
+            history.append(start[0])
+            layout["main"].update(render_status(history))

src/subsystem/autonome_sys/autonome.py

@@ -0,0 +1,8 @@
+import os
+import feedparser
+
+def autonome_chain():
+    while True:
+        i = 1
+
+

src/subsystem/create_event.py

@@ -0,0 +1,47 @@
+# Refer to the Python quickstart on how to setup the environment:
+# https://developers.google.com/workspace/calendar/quickstart/python
+# Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
+# stored credentials.
+from googleapiclient.discovery import build
+from src.subsystem.get_creds import get_creds
+
+def create_event(title: str, description: str, startTime: str, endTime: str):
+    """
+    Summary:
+        Create a event in your google calendar
+    Args: 
+        title: just a title
+        description: just a description
+        startTime: start of your event like this '2026-09-09T09:00:00-07:00'
+        endTime: same type of startTime
+    """
+    creds = get_creds()
+    service = build("calendar", "v3", credentials=creds)
+    event = {
+      'summary': title,
+      'location': 'None',
+      'description': description,
+      'start': {
+        'dateTime': startTime,
+        'timeZone': 'Europe/Paris',
+      },
+      'end': {
+        'dateTime': endTime,
+        'timeZone': 'Europe/Paris',
+      },
+      'recurrence': [
+        'RRULE:FREQ=DAILY;COUNT=1'
+      ],
+      'reminders': {
+        'useDefault': False,
+        'overrides': [
+          {'method': 'email', 'minutes': 24 * 60},
+          {'method': 'popup', 'minutes': 10},
+        ],
+      },
+    }
+
+    event = service.events().insert(calendarId='primary', body=event).execute()
+    print('Event created: %s' % (event.get('htmlLink')))
+    return "'Event created: %s' % (event.get('htmlLink'))"
+

src/subsystem/get_creds.py

@@ -0,0 +1,30 @@
+import os
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+
+SCOPES = ["https://www.googleapis.com/auth/calendar", "https://www.googleapis.com/auth/gmail.modify",]
+
+def get_creds():
+    """
+    Summary:
+        Create or check your actual token. If not exist, Tranquillity create it
+    """
+    creds = None
+    if os.path.exists("token.json"):
+        creds = Credentials.from_authorized_user_file("token.json", SCOPES)
+    # If there are no (valid) credentials available, let the user log in.
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+          creds.refresh(Request())
+        else:
+          flow = InstalledAppFlow.from_client_secrets_file(
+              "./settings/credentials.json", SCOPES
+          )
+          creds = flow.run_local_server(port=0)
+        # Save the credentials for the next run
+        with open("token.json", "w") as token:
+          token.write(creds.to_json())
+    return creds

src/subsystem/get_email.py

@@ -0,0 +1,101 @@
+import requests
+import os
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+import base64
+import html2text
+from src.subsystem.get_creds import get_creds
+
+def get_header(payload, name):
+    for h in payload["headers"]:
+        if h["name"].lower() == name.lower():
+            return h["value"]
+    return ""
+
+def html_to_text(html_content: str) -> str:
+    h = html2text.HTML2Text()
+    h.ignore_links = True
+    h.ignore_images = True
+    h.body_width = 0
+    return h.handle(html_content).strip()
+
+def get_body(payload):
+    plain_text = None
+    html_text = None
+
+    if "parts" in payload:
+        for part in payload["parts"]:
+            # gère aussi les parts imbriquées (multipart/alternative dans multipart/mixed)
+            if part.get("parts"):
+                nested = get_body(part)
+                if nested:
+                    return nested
+            if part["mimeType"] == "text/plain" and not plain_text:
+                data = part["body"].get("data")
+                if data:
+                    plain_text = base64.urlsafe_b64decode(data).decode("utf-8", errors="replace")
+            elif part["mimeType"] == "text/html" and not html_text:
+                data = part["body"].get("data")
+                if data:
+                    html_text = base64.urlsafe_b64decode(data).decode("utf-8", errors="replace")
+    else:
+        data = payload.get("body", {}).get("data")
+        if data:
+            decoded = base64.urlsafe_b64decode(data).decode("utf-8", errors="replace")
+            if payload.get("mimeType") == "text/html":
+                html_text = decoded
+            else:
+                plain_text = decoded
+
+    if plain_text and plain_text.strip():
+        return plain_text.strip()
+    if html_text:
+        return html_to_text(html_text)
+    return ""
+
+def get_email(number: int):
+  """Shows basic usage of the Gmail API.
+  Lists the user's Gmail labels.
+  """
+  creds = get_creds()
+  try:
+    # Call the Gmail API and limit the result to the requested number of emails.
+    service = build("gmail", "v1", credentials=creds)
+    results = (
+        service.users().messages().list(
+            userId="me", labelIds=["INBOX"], maxResults=number
+        ).execute()
+    )
+    messages = results.get("messages", [])
+
+    if not messages:
+        print("No messages found.")
+        return
+
+    print("Messages:")
+    content = []
+    for message in messages:
+        print(f'Message ID: {message["id"]}')
+        msg = (
+            service.users().messages().get(
+                userId="me", id=message["id"], format="full"
+            ).execute()
+        )
+        subject = get_header(msg["payload"], "Subject")
+        date = get_header(msg["payload"], "Date")
+        sender = get_header(msg["payload"], "From")
+        body = get_body(msg["payload"])
+        print(sender)
+        print(date)
+        print(subject)
+        print(body)
+        content.append(f"Sender : {sender}.\n Date : {date}.\n Subject: {subject}.\n Body: {body}\n")
+    return "\n".join(content)
+        
+
+  except HttpError as error:
+    # TODO(developer) - Handle errors from gmail API.
+    print(f"An error occurred: {error}")

src/subsystem/list_event.py

@@ -0,0 +1,65 @@
+import datetime
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from src.subsystem.get_creds import get_creds
+from datetime import datetime as normaldatetime
+from zoneinfo import ZoneInfo
+
+# If modifying these scopes, delete the file token.json.
+SCOPES = ["https://www.googleapis.com/auth/calendar.readonly", "https://www.googleapis.com/auth/gmail.readonly",]
+
+
+def format_event_time(iso_string: str) -> str:
+    if "T" not in iso_string:
+        # événement toute la journée, pas d'heure
+        return iso_string
+    dt_utc = normaldatetime.fromisoformat(iso_string.replace("Z", "+00:00"))
+    dt_paris = dt_utc.astimezone(ZoneInfo("Europe/Paris"))
+    return dt_paris.strftime("%Y-%m-%d %H:%M")
+
+def list_calendar(number: int):
+  """Shows basic usage of the Google Calendar API.
+  Prints the start and name of the next 10 events on the user's calendar.
+  """
+  creds = get_creds()
+  
+  try:
+    service = build("calendar", "v3", credentials=creds)
+
+    # Call the Calendar API
+    now = datetime.datetime.now(tz=datetime.timezone.utc).isoformat()
+    print("Getting the upcoming 10 events")
+    events_result = (
+        service.events()
+        .list(
+            calendarId="primary",
+            timeMin=now,
+            maxResults=number,
+            singleEvents=True,
+            orderBy="startTime",
+        )
+        .execute()
+    )
+    events = events_result.get("items", [])
+
+    if not events:
+      print("No upcoming events found.")
+      return ""
+
+    content = []
+    # Prints the start and name of the next 10 events
+    for event in events:
+      start = event["start"].get("dateTime", event["start"].get("date"))
+      print(format_event_time(start), event["summary"])
+      temp_content = f"{start} - {event["summary"]}"
+      content.append(temp_content)
+    return "\n".join(content)
+
+  except HttpError as error:
+    print(f"An error occurred: {error}")
+
+if __name__ == "__main__":
+  list_calendar(5)

src/subsystem/notification_system.py

@@ -0,0 +1,17 @@
+import json
+import os
+import requests
+import secrets
+from pathlib import Path
+import asyncio
+import httpx
+
+async def send_discord_message(text: str):
+    async with httpx.AsyncClient() as client:
+        r = await client.post(
+            "https://gla-dos-prod.up.railway.app/discord/say",
+            json={"text": text},
+            headers={"X-Glados-Key": os.getenv("API_KEY")},
+        )
+        r.raise_for_status()
+        return r.json()

src/subsystem/search_web.py

@@ -0,0 +1,48 @@
+import os
+import requests
+
+def search_web(query: str) -> str:
+    api_key = os.getenv("NEWSAPI_KEY")
+    if not api_key:
+        return "Erreur : clé NEWSAPI_KEY manquante dans les variables d'environnement."
+
+    mots_generaux = ["actualité", "actualités", "info", "infos", "news", "dernières", "nouvelles"]
+    is_general = any(mot in query.lower() for mot in mots_generaux)
+    q = "France" if is_general else query
+
+    try:
+        resp = requests.get(
+            "https://newsapi.org/v2/everything",
+            params={
+                "q": q,
+                "language": "fr",
+                "sortBy": "publishedAt",
+                "pageSize": 5,
+                "apiKey": api_key,
+            },
+            timeout=8,
+        )
+        data = resp.json()
+
+        if data.get("status") != "ok":
+            return f"Erreur API actualités : {data.get('message', 'inconnue')}"
+
+        articles = data.get("articles", [])
+        if not articles:
+            return "Aucun résultat trouvé pour cette recherche."
+
+        lignes = []
+        for a in articles:
+            titre = a.get("title", "").strip()
+            source = a.get("source", {}).get("name", "")
+            description = (a.get("description") or "").strip()
+            if titre:
+                ligne = f"- {titre} ({source})"
+                if description:
+                    ligne += f" : {description}"
+                lignes.append(ligne)
+
+        return "\n".join(lignes) if lignes else "Aucun résultat exploitable trouvé."
+
+    except requests.exceptions.RequestException as e:
+        return f"Erreur réseau lors de la recherche : {e}"

src/tranquillity.py

@@ -0,0 +1,10 @@
+import sys
+from threading import Thread
+from pathlib import Path
+from src.core.gemini import gemini
+from src.subsystem.autonome_sys.autonome import autonome_chain
+
+def init():
+    autonome = Thread(target=autonome_chain, daemon=True)
+    autonome.start()
+    gemini()

tranquillity-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,29 @@
+ctOS.py,sha256=5852cYA5lVpGJrEGc_SjoJEUCwnpbEzidbeGgFIOW_M,1032
+docker_launcher.py,sha256=HosJFPTQi31-F16bSkybnNIezSQ4oczd0jURKpBQ9Nk,985
+settings/settings.py,sha256=SBKpmH8fffXVM_RGimK5v7smRzOHJ2OYFjbWU1tzjZc,193
+src/tranquillity.py,sha256=pPZSyQxZaQcXYTmmpJnk37yYbHUNB6IreJcqHxW9zco,267
+src/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/core/gemini.py,sha256=osnpQTR2GiDLqu9Qcf43TfVVgO3UuPZ3qQB2GxShEW8,8301
+src/ctOS/help.py,sha256=TwRGZJIzUaoDqtPMbjYHGc60fRDTyxE-N-xj9Qgb4o8,1112
+src/ctOS/light/light.py,sha256=ENIpnAXPbhkngL-EaLUwxGRf9kkVOLE0DNVu3q53kdM,335
+src/ctOS/light/toggle_light.py,sha256=iG78Cs8WLRjC8mYyhHwbUZNUf8odZOIWGhHt5VgxplA,410
+src/ctOS/music/get_id_device.py,sha256=osRZqpmZpO80sTAUvr-ZlpgIDItcekupFhcSuakGY-o,424
+src/ctOS/music/get_token_tmp.py,sha256=vZj9VeDWryg4oOrIM4lA0deHpm9l4TqXItS-30rpzcA,3316
+src/ctOS/music/init_token.py,sha256=GF1K0785vT1cnxsTHtcxQH8JIp8gLFcy4RjYhnlINJ4,1181
+src/ctOS/music/music.py,sha256=8Q38Zt6AW7o2RLq6XUHVwwHXazVJRcPnf9huRzfQjVc,630
+src/ctOS/music/pause.py,sha256=mVilxUK8ykWZhwj6wUkrm7SQNW52vAoRvJ-ciYzGOJU,404
+src/ctOS/music/resume.py,sha256=vuBsDPEvIIDzm1Z1HQDdFQGUv5ec7T8hIlkyT2EoyiM,464
+src/ctOS/start/init.py,sha256=f7hCI4-r0T7x_QSegNpm-F4aaSm8MmYcWqjUAHqAuNg,3142
+src/ctOS/start/start.py,sha256=TPQpgpqYM4nxy-GJkdVbEfr7hBzZvDszAZ_kqB5f0Bc,1302
+src/subsystem/create_event.py,sha256=DcQMIWDgAyE5fZ6W3ARyymMIpYTXslp7d4J-MQVqtJQ,1499
+src/subsystem/get_creds.py,sha256=abSccAwzhYNT7DINRXM2cvOD358i1QdSoSr9lzQanfs,1158
+src/subsystem/get_email.py,sha256=vUXQjIb6NveiU78QvzTOIRqXjls2mnnZgvYMxUM7F24,3345
+src/subsystem/list_event.py,sha256=mJXiG54LBTUZ4lGDYdNJcGk6frYimlMCCYpAhzpyoAM,2127
+src/subsystem/notification_system.py,sha256=r1MyBn5S0EJnabGmcnOYfd-aF5GgyOOYQWWFL_hRvLs,446
+src/subsystem/search_web.py,sha256=-64AejTzF0B1G8XVsLwgCcroOSSOSrWVzMpRfRi3ecI,1635
+src/subsystem/autonome_sys/autonome.py,sha256=1wxQqIspCuF0w5_gOAsKDn9y8aQ-Bt5g_9QIfV4Oj00,83
+tranquillity-0.1.0.dist-info/METADATA,sha256=I6H2xRytqQMnnW4VwHDQjDOw49qD04Xw-GJBjbdqtsw,899
+tranquillity-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+tranquillity-0.1.0.dist-info/entry_points.txt,sha256=v9iaIcdDzmX2dsMrhd-Hmyf8vejSH7wRrTS_hHbdmKI,54
+tranquillity-0.1.0.dist-info/top_level.txt,sha256=YxzuiHTGqHg_QHX9c0dchVO2jyu-gNFySLi324i9ZEo,34
+tranquillity-0.1.0.dist-info/RECORD,,

tranquillity-0.1.0.dist-info/WHEEL

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

tranquillity-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tranquillity = docker_launcher:main

tranquillity-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+ctOS
+docker_launcher
+settings
+src