PageBot/pagebot.py

#!/usr/bin/python3
import asyncio
import discord
import os
import subprocess
import time
import secrets_file
import threading
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import speech_recognition as sr

def wait_for_file_ready(filepath, stable_seconds=1, timeout=60):
    elapsed = 0
    last_size = -1
    stable_time = 0
    while elapsed < timeout:
        try:
            size = os.path.getsize(filepath)
        except OSError:
            return False
        if size == last_size:
            stable_time += 1
            if stable_time >= stable_seconds:
                return True
        else:
            stable_time = 0
        last_size = size
        time.sleep(1)
        elapsed += 1
    return False

last_file_time = time.time()
_processing_lock = threading.Lock()
_processing_files = set()

class MyHandler(FileSystemEventHandler):
    def on_created(self, event):
        global last_file_time
        if event.is_directory:
            return
        last_file_time = time.time()
        filepath = event.src_path
        filename, file_extension = os.path.splitext(filepath)
        if file_extension.lower() == '.amr':
            with _processing_lock:
                if filepath in _processing_files:
                    return
                _processing_files.add(filepath)
            try:
                wait_for_file_ready(filepath)
                os.remove(filepath)
                print("Removing AMR.")
            finally:
                with _processing_lock:
                    _processing_files.discard(filepath)
        if file_extension.lower() == '.mp3':
            with _processing_lock:
                if filepath in _processing_files:
                    return
                _processing_files.add(filepath)
            try:
                print("New MP3!")
                wait_for_file_ready(filepath)
                text = ""
                if secrets_file.speech_to_text:
                    print("Converting To Text and MP4")
                    text_result = [""]
                    def do_text():
                        text_result[0] = convert_to_text(filepath, filename)
                    text_thread = threading.Thread(target=do_text)
                    text_thread.start()
                    mp4_file = convert_to_mp4(filepath, delete_source=False)
                    text_thread.join()
                    text = text_result[0]
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass
                else:
                    print("Converting to MP4")
                    mp4_file = convert_to_mp4(filepath)
                print("Sending to Discord")
                asyncio.run_coroutine_threadsafe(upload_to_discord(mp4_file, text), client.loop)
            finally:
                with _processing_lock:
                    _processing_files.discard(filepath)

def convert_to_mp4(mp3_file, delete_source=True):
    try:
        mp4_file = os.path.splitext(mp3_file)[0] + '.mp4'
        subprocess.run([
            'ffmpeg', '-y', '-loop', '1',
            '-i', secrets_file.image_path,
            '-i', mp3_file,
            '-c:a', 'aac', '-b:a', '192k',
            '-c:v', 'libx264', '-pix_fmt', 'yuv420p',
            '-shortest', mp4_file
        ])
        if delete_source:
            os.remove(mp3_file)
        return mp4_file
    except Exception as e:
        print(f"Error during conversion: {e}")
        return None

def convert_to_text(mp3_path, mp3_name):
    print(mp3_path)
    try:
        wav_file = f"{mp3_name}.wav"
        subprocess.run(['ffmpeg', '-y', '-i', mp3_path, wav_file])
        r = sr.Recognizer()
        with sr.AudioFile(wav_file) as source:
            data = r.record(source)
        text = r.recognize_google(data)
        os.remove(wav_file)
        return text
    except Exception as e:
        print(f"Error during conversion: {e}")
        return ""

async def upload_to_discord(mp4_file, text):
    if mp4_file is None:
        print("Conversion failed. Skipping upload.")
        return
    channel = client.get_channel(secrets_file.channel_id)
    if channel:
        filename = os.path.basename(mp4_file)
        with open(mp4_file, 'rb') as f:
            await channel.send(filename, file=discord.File(f))
        if secrets_file.delete_after_upload:
            os.remove(mp4_file)
        if text != "":
            await channel.send(f"The following text was transcoded from the recording: \n{text}")
        role_name = filename.split('-', 1)[0].strip()
        role = discord.utils.get(channel.guild.roles, name=role_name)
        if role:
            await channel.send(f"{role.mention} {secrets_file.notify_text}")
        else:
            print(f"Role '{role_name}' not found.")
    else:
        print(f"Could not find channel with ID {secrets_file.channel_id}")

TTD_TIMEOUT = getattr(secrets_file, 'ttd_timeout', 900)

def kill_process_tree(pid):
    try:
        subprocess.run(['taskkill', '/F', '/T', '/PID', str(pid)],
                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    except Exception as e:
        print(f"Error killing process tree: {e}")

def launch_and_watch(program_path):
    global last_file_time
    program_directory = os.path.dirname(program_path)
    while True:
        last_file_time = time.time()
        process = subprocess.Popen(program_path, cwd=program_directory)
        while True:
            try:
                process.wait(timeout=30)
                break
            except subprocess.TimeoutExpired:
                if time.time() - last_file_time > TTD_TIMEOUT:
                    print("TTD appears to have locked up (no new files in 15 minutes). Restarting...")
                    kill_process_tree(process.pid)
                    break
        if process.returncode is None or process.returncode != 0:
            print("TTD has crashed. Relaunching...")
            kill_process_tree(process.pid)
        else:
            print("TTD has exited normally.")
            break
        time.sleep(10)

if __name__ == "__main__":
    observer = Observer()

    intents = discord.Intents.default()
    intents.message_content = True
    client = discord.Client(intents=intents)

    @client.event
    async def on_ready():
        print(f'We have logged in as {client.user}')

        event_handler = MyHandler()
        observer.schedule(event_handler, secrets_file.watch_folder, recursive=False)
        observer.start()

        if secrets_file.ttd_path != "":
            watchdog_thread = threading.Thread(target=launch_and_watch, args=(secrets_file.ttd_path,), daemon=True)
            watchdog_thread.start()

    try:
        client.run(secrets_file.key)
    finally:
        observer.stop()
        observer.join()