GameSentenceMiner 2.14.9__py3-none-any.whl → 2.14.10__py3-none-any.whl

GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py

@@ -0,0 +1,109 @@
+from multiprocessing import Process, Manager
+import mss
+from PIL import Image
+
+try:
+    from PIL import ImageTk
+    import tkinter as tk
+    selector_available = True
+except:
+    selector_available = False
+
+
+class ScreenSelector:
+    def __init__(self, result):
+        self.sct = mss.mss()
+        self.monitors = self.sct.monitors[1:]
+        self.root = None
+        self.result = result
+
+    def on_select(self, monitor, coordinates):
+        self.result['monitor'] = monitor
+        self.result['coordinates'] = coordinates
+        self.root.destroy()
+
+    def create_window(self, monitor):
+        screenshot = self.sct.grab(monitor)
+        img = Image.frombytes('RGB', screenshot.size, screenshot.rgb)
+
+        if img.width != monitor['width']:
+            img = img.resize((monitor['width'], monitor['height']), Image.Resampling.LANCZOS)
+
+        window = tk.Toplevel(self.root)
+        window.geometry(f"{monitor['width']}x{monitor['height']}+{monitor['left']}+{monitor['top']}")
+        window.overrideredirect(1)
+        window.attributes('-topmost', 1)
+
+        img_tk = ImageTk.PhotoImage(img)
+
+        canvas = tk.Canvas(window, cursor='cross', highlightthickness=0)
+        canvas.pack(fill=tk.BOTH, expand=True)
+        canvas.image = img_tk
+        canvas.create_image(0, 0, image=img_tk, anchor=tk.NW)
+
+        start_x, start_y, rect = None, None, None
+
+        def on_click(event):
+            nonlocal start_x, start_y, rect
+            start_x, start_y = event.x, event.y
+            rect = canvas.create_rectangle(start_x, start_y, start_x, start_y, outline='red')
+
+        def on_drag(event):
+            nonlocal rect, start_x, start_y
+            if rect:
+                canvas.coords(rect, start_x, start_y, event.x, event.y)
+
+        def on_release(event):
+            nonlocal start_x, start_y
+            end_x, end_y = event.x, event.y
+
+            x1 = min(start_x, end_x)
+            y1 = min(start_y, end_y)
+            x2 = max(start_x, end_x)
+            y2 = max(start_y, end_y)
+
+            self.on_select(monitor, (x1, y1, x2 - x1, y2 - y1))
+
+        canvas.bind('<ButtonPress-1>', on_click)
+        canvas.bind('<B1-Motion>', on_drag)
+        canvas.bind('<ButtonRelease-1>', on_release)
+
+    def start(self):
+        self.root = tk.Tk()
+        self.root.withdraw()
+
+        for monitor in self.monitors:
+            self.create_window(monitor)
+
+        self.root.mainloop()
+        self.root.update()
+
+
+def run_screen_selector(result):
+    selector = ScreenSelector(result)
+    selector.start()
+
+
+def get_screen_selection():
+    if not selector_available:
+        raise ValueError('tkinter or PIL with tkinter support are not installed, unable to open picker')
+
+    with Manager() as manager:
+        res = manager.dict()
+        process = Process(target=run_screen_selector, args=(res,))
+
+        process.start()
+        process.join()
+
+        if 'monitor' in res and 'coordinates' in res:
+            return res.copy()
+        else:
+            return False
+
+if __name__ == "__main__":
+    selection = get_screen_selection()
+    if selection:
+        print(f"Selected monitor: {selection['monitor']}")
+        print(f"Selected coordinates: {selection['coordinates']}")
+    else:
+        print("No selection made or process was interrupted.")

GameSentenceMiner/tools/audio_offset_selector.py

@@ -0,0 +1,215 @@
+
+import os
+import sys
+
+sys_stdout = sys.stdout
+sys_stderr = sys.stderr
+sys.stdout = open(os.devnull, 'w')
+sys.stderr = open(os.devnull, 'w')
+import tkinter as tk
+from tkinter import filedialog, messagebox
+import soundfile as sf
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+import sounddevice as sd
+
+from GameSentenceMiner.util import ffmpeg
+
+
+class AudioOffsetGUI:
+
+    def __init__(self, master, audio_file_path=None):
+        self.master = master
+        master.title("Audio Offset Adjuster")
+        master.geometry("1000x700")
+
+        master.tk_setPalette(background='#2E2E2E', foreground='white',
+                             activeBackground='#4F4F4F', activeForeground='white')
+
+        self.audio_data = None
+        self.samplerate = None
+        self.duration = 0.0
+
+        self.fig, self.ax = plt.subplots(figsize=(10, 4))
+        self.canvas = FigureCanvasTkAgg(self.fig, master=master)
+        self.canvas_widget = self.canvas.get_tk_widget()
+        self.canvas_widget.pack(side=tk.TOP, fill=tk.BOTH, expand=True, padx=10, pady=10)
+
+        plt.style.use('dark_background')
+        self.fig.set_facecolor('#2E2E2E')
+        self.ax.set_facecolor('#2E2E2E')
+        self.ax.tick_params(axis='x', colors='white')
+        self.ax.tick_params(axis='y', colors='white')
+        self.ax.spines['bottom'].set_color('white')
+        self.ax.spines['left'].set_color('white')
+        self.ax.spines['top'].set_color('white')
+        self.ax.spines['right'].set_color('white')
+        self.ax.set_xlabel("Time (s)", color='white')
+        self.ax.set_ylabel("Amplitude", color='white')
+
+        self.beg_offset_line = None
+        # self.end_offset_line is removed as there's no end slider
+
+        self.create_widgets()
+
+        self.load_audio(audio_file_path)
+
+
+    def create_widgets(self):
+        control_frame = tk.Frame(self.master, bg='#2E2E2E')
+        control_frame.pack(side=tk.BOTTOM, fill=tk.X, pady=10, padx=10)
+
+        self.play_button = tk.Button(control_frame, text="Play/Pause Segment", command=self.play_segment, bg='#4F4F4F', fg='white')
+        self.play_button.pack(side=tk.RIGHT, padx=5)
+
+        self.output_button = tk.Button(control_frame, text="Get Offset", command=self.get_offsets, bg='#4F4F4F', fg='white')
+        self.output_button.pack(side=tk.RIGHT, padx=5)
+
+        self.beg_offset_label = tk.Label(control_frame, text="Beginning Offset: 0.00s", bg='#2E2E2E', fg='white')
+        self.beg_offset_label.pack(side=tk.LEFT, padx=10)
+
+        self.end_offset_label = tk.Label(control_frame, text="End Offset: Full Duration", bg='#2E2E2E', fg='white')
+        self.end_offset_label.pack(side=tk.LEFT, padx=10)
+
+        slider_frame = tk.Frame(self.master, bg='#2E2E2E')
+        slider_frame.pack(side=tk.BOTTOM, fill=tk.X, pady=5, padx=10)
+
+        beg_slider_label = tk.Label(slider_frame, text="Start Trim:", bg='#2E2E2E', fg='white')
+        beg_slider_label.pack(side=tk.LEFT)
+        self.beg_slider = tk.Scale(slider_frame, from_=0, to=100, orient=tk.HORIZONTAL, resolution=0.5,
+                                   command=self.on_slider_change, bg='#2E2E2E', fg='white', troughcolor='#4F4F4F',
+                                   highlightbackground='#2E2E2E', length=300)
+        self.beg_slider.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=5)
+
+        # Removed end_slider and its associated label
+
+    def load_audio(self, file_path):
+        if file_path:
+            try:
+                self.audio_data, self.samplerate = sf.read(file_path)
+                if self.audio_data.ndim > 1:
+                    self.audio_data = self.audio_data[:, 0]
+                self.duration = len(self.audio_data) / self.samplerate
+                self.plot_waveform()
+                self.beg_slider.config(to=self.duration)
+                self.beg_slider.set(0) # Reset start slider to 0
+            except Exception as e:
+                messagebox.showerror("Error", f"Failed to load audio file: {e}")
+                self.audio_data = None
+                self.samplerate = None
+                self.duration = 0.0
+
+    def plot_waveform(self):
+        self.ax.clear()
+        if self.audio_data is not None:
+            time = np.linspace(0, self.duration, len(self.audio_data))
+            self.ax.plot(time, self.audio_data, color='#1E90FF')
+            self.ax.set_xlim(0, self.duration)
+            self.ax.set_ylim(np.min(self.audio_data), np.max(self.audio_data))
+            self.ax.set_title("Audio", color='white')
+
+            if self.beg_offset_line:
+                self.beg_offset_line.remove()
+            # self.end_offset_line.remove() is removed
+
+            self.beg_offset_line = self.ax.axvline(self.beg_slider.get(), color='red', linestyle='--', linewidth=2)
+            # The end line is now always at the duration
+            self.ax.axvline(self.duration, color='green', linestyle='--', linewidth=2)
+
+            self.update_offset_labels()
+        else:
+            self.ax.text(0.5, 0.5, "No audio loaded",
+                         horizontalalignment='center', verticalalignment='center',
+                         transform=self.ax.transAxes, color='white', fontsize=16)
+
+        self.fig.canvas.draw_idle()
+
+    def on_slider_change(self, val):
+        if self.audio_data is None:
+            return
+
+        beg_val = float(self.beg_slider.get())
+
+        if self.beg_offset_line:
+            self.beg_offset_line.set_xdata([beg_val])
+
+        self.update_offset_labels()
+        self.fig.canvas.draw_idle()
+
+    def play_segment(self):
+        if self.audio_data is None:
+            messagebox.showinfo("Play Audio", "No audio file loaded yet.")
+            return
+
+        if hasattr(self, 'is_playing') and self.is_playing:
+            sd.stop()
+            self.is_playing = False
+            return
+
+        beg_offset = self.beg_slider.get()
+        end_offset = self.duration # End offset is now always full duration
+
+        if beg_offset >= end_offset:
+            messagebox.showwarning("Play Audio", "Start offset must be less than end offset.")
+            return
+
+        start_frame = int(beg_offset * self.samplerate)
+        end_frame = int(end_offset * self.samplerate)
+
+        if start_frame >= len(self.audio_data) or end_frame <= 0:
+            messagebox.showwarning("Play Audio", "Selected segment is out of audio range.")
+            return
+
+        segment_to_play = self.audio_data[start_frame:end_frame]
+
+        try:
+            self.is_playing = True
+            sd.play(segment_to_play, self.samplerate)
+        except Exception as e:
+            self.is_playing = False
+            messagebox.showerror("Audio Playback Error", f"Failed to play audio: {e}")
+
+    def update_offset_labels(self):
+        if self.beg_offset_line:  # We no longer have an end_offset_line object
+            beg_val = self.beg_offset_line.get_xdata()[0] - 5.0  # Adjusting for the 5 seconds offset
+            self.beg_offset_label.config(text=f"Beginning Offset: {beg_val:.2f}s")
+
+    def get_offsets(self):
+        if self.audio_data is None:
+            messagebox.showinfo("Offsets", "No audio file loaded yet.")
+            return
+
+        beg_offset = self.beg_slider.get() - 5.0
+        end_offset = self.duration # End offset is always full duration
+        sys.stdout.close()
+        sys.stderr.close()
+        sys.stdout = sys_stdout
+        sys.stderr = sys_stderr
+        print(f"{beg_offset:.2f}")
+        exit(0)
+
+def run_audio_offset_gui(path=None, beginning_offset=0, end_offset=None):
+    temp_file_path = os.path.join(os.path.dirname(path), "temp_audio.opus")
+
+    if os.path.exists(temp_file_path):
+        os.remove(temp_file_path)
+
+    ffmpeg.trim_audio(path, beginning_offset - 5, end_offset, temp_file_path, True, 0, 0)
+
+    root = tk.Tk()
+    root.protocol("WM_DELETE_WINDOW", lambda: exit(1))  # Exit when the window is closed
+    app = AudioOffsetGUI(root, audio_file_path=temp_file_path)
+    root.mainloop()
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Run Audio Offset GUI")
+    parser.add_argument("--path", type=str, required=True, help="Path to the audio file")
+    parser.add_argument("--beginning_offset", type=float, default=0, help="Beginning offset in seconds")
+    parser.add_argument("--end_offset", type=float, default=None, help="End offset in seconds")
+
+    args = parser.parse_args()
+    run_audio_offset_gui(path=args.path, beginning_offset=args.beginning_offset, end_offset=args.end_offset)

GameSentenceMiner/tools/ss_selector.py

@@ -0,0 +1,135 @@
+
+
+import os
+import sys
+import subprocess
+
+# Suppress stdout and stderr during imports
+sys_stdout = sys.stdout
+sys_stderr = sys.stderr
+sys.stdout = open(os.devnull, 'w')
+sys.stderr = open(os.devnull, 'w')
+
+import tkinter as tk
+from PIL import Image, ImageTk
+from GameSentenceMiner.util.gsm_utils import sanitize_filename
+from GameSentenceMiner.util.configuration import get_temporary_directory, logger
+from GameSentenceMiner.util.ffmpeg import ffmpeg_base_command_list
+from GameSentenceMiner.util import ffmpeg
+
+def extract_frames(video_path, timestamp, temp_dir, mode):
+    frame_paths = []
+    timestamp_number = float(timestamp)
+    golden_frame_index = 1  # Default to the first frame
+    golden_frame = None
+    video_duration = ffmpeg.get_video_duration(video_path)
+
+    if mode == 'middle':
+        timestamp_number = max(0.0, timestamp_number - 2.5)
+    elif mode == 'end':
+        timestamp_number = max(0.0, timestamp_number - 5.0)
+
+    if video_duration is not None and timestamp_number > video_duration:
+        logger.debug(f"Timestamp {timestamp_number} exceeds video duration {video_duration}.")
+        return None
+
+    try:
+        command = ffmpeg_base_command_list + [
+            "-y",
+            "-ss", str(timestamp_number),
+            "-i", video_path,
+            "-vf", f"fps=1/{0.25}",
+            "-vframes", "20",
+            os.path.join(temp_dir, "frame_%02d.png")
+        ]
+        subprocess.run(command, check=True, capture_output=True)
+        for i in range(1, 21):
+            if os.path.exists(os.path.join(temp_dir, f"frame_{i:02d}.png")):
+                frame_paths.append(os.path.join(temp_dir, f"frame_{i:02d}.png"))
+
+        if mode == "beginning":
+            golden_frame = frame_paths[0]
+        if mode == "middle":
+            golden_frame = frame_paths[len(frame_paths) // 2]
+        if mode == "end":
+            golden_frame = frame_paths[-1]
+    except subprocess.CalledProcessError as e:
+        logger.debug(f"Error extracting frames: {e}")
+        logger.debug(f"Command was: {' '.join(command)}")
+        logger.debug(f"FFmpeg output:\n{e.stderr.decode()}")
+        return None
+    except Exception as e:
+        logger.debug(f"An error occurred: {e}")
+        return None
+    return frame_paths, golden_frame
+
+def timestamp_to_seconds(timestamp):
+    hours, minutes, seconds = map(int, timestamp.split(':'))
+    return hours * 3600 + minutes * 60 + seconds
+
+def display_images(image_paths, golden_frame):
+    window = tk.Tk()
+    window.configure(bg="black")  # Set the background color to black
+    window.title("Image Selector")
+    selected_path = tk.StringVar()
+    image_widgets = []
+
+    def on_image_click(event):
+        widget = event.widget
+        index = image_widgets.index(widget)
+        selected_path.set(image_paths[index])
+        window.quit()
+
+    for i, path in enumerate(image_paths):
+        img = Image.open(path)
+        img.thumbnail((img.width / 8, img.height / 8))
+        img_tk = ImageTk.PhotoImage(img)
+        if golden_frame and path == golden_frame:
+            label = tk.Label(window, image=img_tk, borderwidth=5, relief="solid")
+            label.config(highlightbackground="yellow", highlightthickness=5)
+        else:
+            label = tk.Label(window, image=img_tk)
+        label.image = img_tk
+        label.grid(row=i // 5, column=i % 5, padx=5, pady=5)
+        label.bind("<Button-1>", on_image_click)  # Bind click event to the label
+        image_widgets.append(label)
+
+    window.attributes("-topmost", True)
+    window.mainloop()
+    return selected_path.get()
+
+def run_extraction_and_display(video_path, timestamp_str, mode):
+    temp_dir = os.path.join(get_temporary_directory(False), "screenshot_frames", sanitize_filename(os.path.splitext(os.path.basename(video_path))[0]))
+    os.makedirs(temp_dir, exist_ok=True)
+    image_paths, golden_frame = extract_frames(video_path, timestamp_str, temp_dir, mode)
+    if image_paths:
+        selected_image_path = display_images(image_paths, golden_frame)
+        if selected_image_path:
+            sys.stdout.close()
+            sys.stderr.close()
+            sys.stdout = sys_stdout
+            sys.stderr = sys_stderr
+            print(selected_image_path)
+        else:
+            logger.debug("No image was selected.")
+    else:
+        logger.debug("Frame extraction failed.")
+
+def main():
+
+
+    # if len(sys.argv) != 3:
+    #     print("Usage: python script.py <video_path> <timestamp>")
+    #     sys.exit(1)
+    try:
+        video_path = sys.argv[1]
+        timestamp_str = sys.argv[2]
+        mode = sys.argv[3] if len(sys.argv) > 3 else "beginning"
+        run_extraction_and_display(video_path, timestamp_str, mode)
+    except Exception as e:
+        logger.debug(e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

GameSentenceMiner/tools/window_transparency.py

@@ -0,0 +1,214 @@
+import sys
+import win32gui
+import win32con
+import win32api
+import keyboard
+import time
+import threading
+import signal
+
+from GameSentenceMiner.util.configuration import logger
+
+# --- Configuration (equivalent to AHK top-level variables) ---
+TRANSPARENT_LEVEL = 1  # Almost invisible (0-255 scale)
+OPAQUE_LEVEL = 255     # Fully opaque
+HOTKEY = 'ctrl+alt+y'
+
+# --- Global State Variables (equivalent to AHK global variables) ---
+is_toggled = False
+target_hwnd = None
+# A lock to prevent race conditions when accessing global state from different threads
+state_lock = threading.Lock()
+
+# --- Core Functions (equivalent to AHK functions) ---
+
+def set_window_transparency(hwnd, transparency):
+    """
+    Sets the transparency of a window.
+    This is the Python equivalent of WinSetTransparent.
+    """
+    if not hwnd or not win32gui.IsWindow(hwnd):
+        return
+    try:
+        # Get the current window style
+        style = win32gui.GetWindowLong(hwnd, win32con.GWL_EXSTYLE)
+        # Add the WS_EX_LAYERED style, which is required for transparency
+        win32gui.SetWindowLong(hwnd, win32con.GWL_EXSTYLE, style | win32con.WS_EX_LAYERED)
+        # Set the transparency
+        win32gui.SetLayeredWindowAttributes(hwnd, 0, transparency, win32con.LWA_ALPHA)
+    except Exception as e:
+        # Some windows (like system or elevated ones) might deny permission
+        # logger.info(f"Error setting transparency for HWND {hwnd}: {e}")
+        pass
+
+def set_always_on_top(hwnd, is_on_top):
+    """
+    Sets or removes the "Always on Top" status for a window.
+    This is the Python equivalent of WinSetAlwaysOnTop.
+    """
+    if not hwnd or not win32gui.IsWindow(hwnd):
+        return
+    try:
+        rect = win32gui.GetWindowRect(hwnd)
+        position = win32con.HWND_TOPMOST if is_on_top else win32con.HWND_NOTOPMOST
+        # Set the window position without moving or resizing it
+        win32gui.SetWindowPos(hwnd, position, rect[0], rect[1], 0, 0,
+                              win32con.SWP_NOMOVE | win32con.SWP_NOSIZE)
+    except Exception as e:
+        # logger.info(f"Error setting always-on-top for HWND {hwnd}: {e}")
+        pass
+
+def reset_window_state(hwnd):
+    """A helper to reset a window to its default state."""
+    set_window_transparency(hwnd, OPAQUE_LEVEL)
+    set_always_on_top(hwnd, False)
+
+# --- Hotkey Callback (equivalent to AHK ^!y::) ---
+
+def toggle_functionality(window_hwnd=None):
+    """
+    This function is called when the hotkey is pressed.
+    It manages the toggling logic.
+    """
+    global is_toggled, target_hwnd
+    
+    if window_hwnd:
+        current_hwnd = window_hwnd
+    else:
+        # Get the currently focused window (equivalent to WinGetID("A"))
+        current_hwnd = win32gui.GetForegroundWindow()
+        if not current_hwnd:
+            logger.info("No window is currently active!")
+            return
+
+    with state_lock:
+        # Case 1: The hotkey is pressed on the currently toggled window to disable it.
+        if is_toggled and target_hwnd == current_hwnd:
+            logger.info(f"Disabling functionality for window: {win32gui.GetWindowText(current_hwnd)}")
+            reset_window_state(current_hwnd)
+            is_toggled = False
+            target_hwnd = None
+        # Case 2: Enable functionality for a new window, or switch to a new one.
+        else:
+            # If another window was already toggled, reset it first.
+            if is_toggled and target_hwnd is not None:
+                logger.info(f"Resetting old window: {win32gui.GetWindowText(target_hwnd)}")
+                reset_window_state(target_hwnd)
+
+            # Enable functionality for the new window.
+            logger.info(f"Enabling functionality for window: {win32gui.GetWindowText(current_hwnd)}")
+            is_toggled = True
+            target_hwnd = current_hwnd
+            set_always_on_top(target_hwnd, True)
+            # The mouse_monitor_loop will handle setting the initial transparency
+
+# --- Mouse Monitoring (equivalent to AHK Loop) ---
+
+def mouse_monitor_loop():
+    """
+    A loop that runs in a separate thread to monitor the mouse position.
+    """
+    global is_toggled, target_hwnd
+
+    while True:
+        # We check the state without a lock first for performance,
+        # then use the lock when we need to read the shared variable.
+        if is_toggled:
+            with state_lock:
+                # Make a local copy of the target handle to work with
+                monitored_hwnd = target_hwnd
+
+            if monitored_hwnd:
+                # Get mouse position and the window handle under the cursor
+                pos = win32gui.GetCursorPos()
+                hwnd_under_mouse = win32gui.WindowFromPoint(pos)
+
+                # WindowFromPoint can return a child window (like a button).
+                # We need to walk up the parent chain to see if it belongs to our target window.
+                is_mouse_over_target = False
+                current_hwnd = hwnd_under_mouse
+                while current_hwnd != 0:
+                    if current_hwnd == monitored_hwnd:
+                        is_mouse_over_target = True
+                        break
+                    current_hwnd = win32gui.GetParent(current_hwnd)
+
+                # Apply transparency based on mouse position
+                if is_mouse_over_target:
+                    set_window_transparency(monitored_hwnd, OPAQUE_LEVEL)
+                else:
+                    set_window_transparency(monitored_hwnd, TRANSPARENT_LEVEL)
+
+        # A small delay to reduce CPU usage
+        time.sleep(0.1)
+
+class HandleSTDINThread(threading.Thread):
+    def run(self):
+        while True:
+            try:
+                line = input()
+                if "exit" in line.strip().lower():
+                    handle_quit()
+                    break
+            except EOFError:
+                break
+            
+def handle_quit():
+    if is_toggled and target_hwnd:
+        reset_window_state(target_hwnd)
+    logger.info("Exiting Window Transparency Tool.")
+
+# --- Main Execution Block ---
+
+if __name__ == "__main__":
+    import argparse
+    # Start the mouse monitor in a separate, non-blocking thread.
+    # daemon=True ensures the thread will exit when the main script does.
+    monitor_thread = threading.Thread(target=mouse_monitor_loop, daemon=True)
+    monitor_thread.start()
+
+    # get hotkey from args
+    parser = argparse.ArgumentParser(description="Window Transparency Toggle Script")
+    parser.add_argument('--hotkey', type=str, default=HOTKEY, help='Hotkey to toggle transparency (default: ctrl+alt+y)')
+    parser.add_argument('--window', type=str, help='Window title to target (optional)')
+
+    args = parser.parse_args()
+    hotkey = args.hotkey.lower()
+    target_window_title = args.window
+    
+    if target_window_title:
+        # Find the window by title if specified
+        target_hwnd = win32gui.FindWindow(None, target_window_title)
+        logger.info(f"Searching for window with title: {target_window_title}")
+        logger.info(f"Target HWND: {target_hwnd}")
+        if not target_hwnd:
+            logger.error(f"Window with title '{target_window_title}' not found.")
+            sys.exit(1)
+        else:
+            logger.info(f"Target window found: {target_window_title}")
+            toggle_functionality(target_hwnd)  # Enable functionality for the specified window
+
+    # Register the global hotkey
+    keyboard.add_hotkey(hotkey, toggle_functionality)
+
+    # Handle SigINT/SigTERM gracefully
+    def signal_handler(sig, frame):
+        handle_quit()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    logger.info(f"Script running. Press '{hotkey}' on a window to toggle transparency.")
+    logger.info("Press Ctrl+C in this console to exit.")
+    
+    HandleSTDINThread().start()
+
+    # Keep the script running to listen for the hotkey.
+    # keyboard.wait() is a blocking call that waits indefinitely.
+    try:
+        keyboard.wait()
+    except KeyboardInterrupt:
+        if is_toggled and target_hwnd:
+            reset_window_state(target_hwnd)
+        logger.info("\nScript terminated by user.")