obsrename.py

import os
import shutil
import time
import threading
import queue
import tkinter as tk
from tkinter import simpledialog
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

# --- Configuration ---
OUTPUT_DIR = "/Users/evanreilly/Movies"  # Change this to your OBS output directory
FILE_STABILITY_TIME = 0.1  # Time in seconds before considering the file "done"

# --- Global Data ---
file_timestamps = {}  # Track last modified times of files
rename_queue = queue.Queue()  # Queue for rename requests
 
# --- File Watcher Handler ---
class OBSFileHandler(FileSystemEventHandler):
    def on_modified(self, event):
        """Triggered when a file is modified (grows in size)."""
        if not event.is_directory:
            file_path = event.src_path
            file_timestamps[file_path] = time.time()  # Update last modified timestamp
            # Schedule a check after FILE_STABILITY_TIME seconds
            threading.Timer(FILE_STABILITY_TIME, check_if_stable, [file_path]).start()

def check_if_stable(file_path):
    """Checks if the file has remained unchanged for FILE_STABILITY_TIME seconds."""
    if os.path.exists(file_path):
        last_modified = file_timestamps.get(file_path)
        if last_modified and time.time() - last_modified >= FILE_STABILITY_TIME:
            file_timestamps.pop(file_path, None)  # Stop tracking this file
            rename_queue.put(file_path)  # Queue this file for renaming

# --- Custom Rename Dialog ---
class RenameDialog(simpledialog.Dialog):
    """
    A custom dialog that pre-populates the entry field with the file name
    and highlights the base part (up to the file extension).
    """
    def __init__(self, parent, title, prompt, initialvalue, select_end):
        self.prompt = prompt
        self.initialvalue = initialvalue
        self.select_end = select_end  # The position up to which text should be highlighted
        self.result = None
        super().__init__(parent, title)

    def body(self, master):
        # Create a label for the prompt and an entry widget.
        tk.Label(master, text=self.prompt).pack(padx=5, pady=5)
        self.entry = tk.Entry(master, width=25)
        self.entry.pack(padx=5, pady=5)
        # Insert the initial file name.
        self.entry.insert(0, self.initialvalue)
        # Delay setting the selection until after the focus has been set.
        self.entry.after_idle(self.set_selection)
        return self.entry

    def set_selection(self):
        # Highlight the text from the start up to select_end
        self.entry.selection_range(0, self.select_end)
        # Set the insertion cursor to the start of the selection.
        self.entry.icursor(0)

    def apply(self):
        self.result = self.entry.get()

# --- Rename Request Processing ---
def process_rename_request(file_path):
    """Open a custom Tkinter dialog to rename the completed recording.
    If the user cancels or leaves the input blank, no renaming occurs."""
    file_name = os.path.basename(file_path)
    base, ext = os.path.splitext(file_name)  # Split into base and extension

    # Create a hidden Tk root window.
    root = tk.Tk()
    root.withdraw()

    try:
        prompt = f"Enter new name (leave blank to keep original):"
        # Create and show our custom rename dialog.
        # The 'select_end' parameter highlights the base name only.
        dialog = RenameDialog(root, "Recording Complete", prompt, file_name, len(base))
        new_name = dialog.result

        if new_name:
            new_path = os.path.join(OUTPUT_DIR, new_name)
            try:
                shutil.move(file_path, new_path)
                print(f"Renamed {file_path} to {new_path}")
            except Exception as e:
                print(f"Error renaming file: {e}")
        else:
            print(f"No rename provided for {file_path}. File remains unchanged.")
    finally:
        root.update_idletasks()
        root.destroy()

# --- Main ---
if __name__ == "__main__":
    # Set up the file observer
    observer = Observer()
    event_handler = OBSFileHandler()
    observer.schedule(event_handler, OUTPUT_DIR, recursive=False)

    print(f"Watching {OUTPUT_DIR} for completed OBS recordings...")
    observer.start()

    try:
        # Poll the rename_queue in an infinite loop.
        while True:
            try:
                # Wait up to 1 second for a file path in the queue
                file_path = rename_queue.get(timeout=1)
                process_rename_request(file_path)
            except queue.Empty:
                # No rename requests; continue polling
                pass
    except KeyboardInterrupt:
        print("\nStopping watcher...")
        observer.stop()
    observer.join()