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

GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py

@@ -1,109 +0,0 @@
-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

@@ -1,215 +0,0 @@
-
-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

@@ -1,135 +0,0 @@
-
-
-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

@@ -1,214 +0,0 @@
-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.")