python-win-windows-manager 0.1.0__tar.gz

python_win_windows_manager-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

python_win_windows_manager-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: python-win-windows-manager
+Version: 0.1.0
+Summary: Window manager and monitor for Windows
+Project-URL: Homepage, https://github.com/username/repo
+Requires-Python: >=3.13
+Requires-Dist: psutil>=7.2.2
+Requires-Dist: pywin32>=311
+Description-Content-Type: text/markdown
+
+# Windows Window Manager
+
+A Python library for managing Windows windows using `win32gui` and `ctypes`. This project provides a robust interface for identifying, controlling, and monitoring windows on Windows systems.
+
+## Features
+
+- **Window Identification**: Get detailed information about all open windows (Handle, Title, Class Name, PID, Process Name).
+- **Window Search**: Find windows by title or class name with exact or partial matching.
+- **Window Control**:
+  - Minimize, Maximize, Restore
+  - Close
+  - Move and Resize
+  - Set to Foreground
+- **Real-time Monitoring**: Monitor window creation, destruction, and state changes.
+- **Robust Error Handling**: Handles permissions and invalid handles gracefully.
+
+## Installation
+
+This project uses `uv` for dependency management.
+
+1.  Clone the repository.
+2.  Install dependencies:
+    ```bash
+    uv sync
+    ```
+
+## Usage
+
+### Basic Example
+
+```python
+from window_manager import WindowManager
+
+manager = WindowManager()
+
+# List all visible windows
+windows = manager.get_all_windows(visible_only=True)
+for window in windows:
+    print(window)
+
+# Find a window
+notepad = manager.find_windows(title="Notepad")[0]
+
+# Minimize
+manager.minimize_window(notepad.handle)
+
+# Restore
+manager.restore_window(notepad.handle)
+```
+
+### Monitoring Example
+
+```python
+import time
+from window_manager import WindowMonitor
+
+def callback(event, hwnd, title):
+    print(f"Event: {event}, Window: {title}")
+
+monitor = WindowMonitor(callback=callback)
+monitor.start()
+
+try:
+    while True:
+        time.sleep(1)
+except KeyboardInterrupt:
+    monitor.stop()
+```
+
+## Running Tests
+
+```bash
+uv run pytest tests
+```
+
+## Documentation
+
+See [docs/API.md](docs/API.md) for detailed API documentation.

python_win_windows_manager-0.1.0/README.md

@@ -0,0 +1,78 @@
+# Windows Window Manager
+
+A Python library for managing Windows windows using `win32gui` and `ctypes`. This project provides a robust interface for identifying, controlling, and monitoring windows on Windows systems.
+
+## Features
+
+- **Window Identification**: Get detailed information about all open windows (Handle, Title, Class Name, PID, Process Name).
+- **Window Search**: Find windows by title or class name with exact or partial matching.
+- **Window Control**:
+  - Minimize, Maximize, Restore
+  - Close
+  - Move and Resize
+  - Set to Foreground
+- **Real-time Monitoring**: Monitor window creation, destruction, and state changes.
+- **Robust Error Handling**: Handles permissions and invalid handles gracefully.
+
+## Installation
+
+This project uses `uv` for dependency management.
+
+1.  Clone the repository.
+2.  Install dependencies:
+    ```bash
+    uv sync
+    ```
+
+## Usage
+
+### Basic Example
+
+```python
+from window_manager import WindowManager
+
+manager = WindowManager()
+
+# List all visible windows
+windows = manager.get_all_windows(visible_only=True)
+for window in windows:
+    print(window)
+
+# Find a window
+notepad = manager.find_windows(title="Notepad")[0]
+
+# Minimize
+manager.minimize_window(notepad.handle)
+
+# Restore
+manager.restore_window(notepad.handle)
+```
+
+### Monitoring Example
+
+```python
+import time
+from window_manager import WindowMonitor
+
+def callback(event, hwnd, title):
+    print(f"Event: {event}, Window: {title}")
+
+monitor = WindowMonitor(callback=callback)
+monitor.start()
+
+try:
+    while True:
+        time.sleep(1)
+except KeyboardInterrupt:
+    monitor.stop()
+```
+
+## Running Tests
+
+```bash
+uv run pytest tests
+```
+
+## Documentation
+
+See [docs/API.md](docs/API.md) for detailed API documentation.

python_win_windows_manager-0.1.0/docs/API.md

@@ -0,0 +1,85 @@
+# API Reference
+
+## WindowManager
+
+The core class for managing Windows windows.
+
+### `get_all_windows(visible_only: bool = True) -> List[WindowInfo]`
+
+Retrieves all open windows.
+
+- **Parameters**:
+  - `visible_only` (bool): If `True`, only returns visible windows. Defaults to `True`.
+- **Returns**:
+  - A list of `WindowInfo` objects.
+
+### `find_windows(title: Optional[str] = None, class_name: Optional[str] = None, exact_match: bool = False) -> List[WindowInfo]`
+
+Finds windows matching the given criteria.
+
+- **Parameters**:
+  - `title` (str, optional): The window title to search for.
+  - `class_name` (str, optional): The window class name to search for.
+  - `exact_match` (bool): If `True`, requires exact string match. Otherwise, checks for containment. Defaults to `False`.
+- **Returns**:
+  - A list of matching `WindowInfo` objects.
+
+### `get_window_by_handle(handle: int) -> Optional[WindowInfo]`
+
+Retrieves window information by handle.
+
+- **Parameters**:
+  - `handle` (int): The window handle.
+- **Returns**:
+  - A `WindowInfo` object if found, otherwise `None`.
+
+### Window Controls
+
+- `close_window(handle: int) -> bool`: Closes the window.
+- `minimize_window(handle: int) -> bool`: Minimizes the window.
+- `maximize_window(handle: int) -> bool`: Maximizes the window.
+- `restore_window(handle: int) -> bool`: Restores the window.
+- `move_window(handle: int, x: int, y: int, width: int, height: int) -> bool`: Moves and resizes the window.
+- `set_foreground(handle: int) -> bool`: Brings the window to the foreground.
+
+## WindowInfo
+
+A dataclass representing window information.
+
+- **Attributes**:
+  - `handle` (int): The window handle (HWND).
+  - `title` (str): The window title.
+  - `class_name` (str): The window class name.
+  - `pid` (int): The process ID associated with the window.
+  - `process_name` (str, optional): The name of the process.
+  - `rect` (tuple, optional): The window rectangle (left, top, right, bottom).
+  - `is_visible` (bool): Whether the window is visible.
+
+## WindowMonitor
+
+Monitors window events such as creation, destruction, and state changes.
+
+### `__init__(callback: Optional[Callable[[str, int, str], None]] = None)`
+
+Initializes the monitor.
+
+- **Parameters**:
+  - `callback`: A function to call when an event occurs. Signature: `callback(event_name, hwnd, title)`.
+
+### `start()`
+
+Starts the monitoring thread.
+
+### `stop()`
+
+Stops the monitoring thread.
+
+## Events
+
+The following events are monitored:
+- `Create`: Window created.
+- `Destroy`: Window destroyed.
+- `Show`: Window shown.
+- `Hide`: Window hidden.
+- `Foreground`: Window became foreground.
+- `NameChange`: Window title changed.

python_win_windows_manager-0.1.0/examples/demo.py

@@ -0,0 +1,94 @@
+import sys
+import time
+import subprocess
+import os
+
+# Add src to python path
+sys.path.append(os.path.join(os.path.dirname(__file__), "../src"))
+
+from window_manager import WindowManager, WindowMonitor, setup_logger
+
+# Setup logging
+logger = setup_logger("Demo", level=10) # DEBUG
+
+def monitor_callback(event, hwnd, title):
+    print(f"[MONITOR] Event: {event}, HWND: {hwnd}, Title: '{title}'")
+
+def main():
+    manager = WindowManager()
+    monitor = WindowMonitor(callback=monitor_callback)
+    
+    print("Starting Window Monitor...")
+    monitor.start()
+    
+    # List all windows
+    print("\nListing all visible windows:")
+    windows = manager.get_all_windows(visible_only=True)
+    for w in windows[:5]: # Show first 5
+        print(f"  {w}")
+    print(f"Total visible windows: {len(windows)}")
+    
+    # Create a test window (Notepad)
+    print("\nLaunching Notepad for testing...")
+    notepad_process = subprocess.Popen("notepad.exe")
+    time.sleep(2) # Wait for window to appear
+    
+    # Find Notepad window
+    print("\nFinding Notepad window...")
+    notepad_windows = manager.find_windows(title="Notepad", exact_match=False)
+    
+    if not notepad_windows:
+        print("Could not find Notepad window!")
+        monitor.stop()
+        notepad_process.terminate()
+        return
+
+    target_window = notepad_windows[0]
+    print(f"Found: {target_window}")
+    
+    hwnd = target_window.handle
+    
+    # Test manipulations
+    print("\nTesting manipulations:")
+    
+    print("  Minimizing...")
+    manager.minimize_window(hwnd)
+    time.sleep(1)
+    
+    print("  Restoring...")
+    manager.restore_window(hwnd)
+    time.sleep(1)
+    
+    print("  Maximizing...")
+    manager.maximize_window(hwnd)
+    time.sleep(1)
+    
+    print("  Restoring...")
+    manager.restore_window(hwnd)
+    time.sleep(1)
+    
+    print("  Moving to (100, 100) with size 800x600...")
+    manager.move_window(hwnd, 100, 100, 800, 600)
+    time.sleep(1)
+    
+    # Verify monitoring caught these events
+    print("\nWaiting for events to be logged...")
+    time.sleep(2)
+    
+    # Close Notepad
+    print("\nClosing Notepad...")
+    manager.close_window(hwnd)
+    time.sleep(1)
+    
+    # Stop monitor
+    print("\nStopping Monitor...")
+    monitor.stop()
+    
+    # Ensure process is gone
+    if notepad_process.poll() is None:
+        notepad_process.terminate()
+        
+    print("\nDemo completed.")
+
+if __name__ == "__main__":
+    main()

python_win_windows_manager-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "python-win-windows-manager"
+version = "0.1.0"
+description = "Window manager and monitor for Windows"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "psutil>=7.2.2",
+    "pywin32>=311",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+]
+[project.urls]
+"Homepage" = "https://github.com/username/repo"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/window_manager"]

python_win_windows_manager-0.1.0/src/window_manager/__init__.py

@@ -0,0 +1,6 @@
+from .core import WindowManager
+from .models import WindowInfo
+from .monitor import WindowMonitor
+from .utils import setup_logger
+
+__all__ = ["WindowManager", "WindowInfo", "WindowMonitor", "setup_logger"]

python_win_windows_manager-0.1.0/src/window_manager/core.py

@@ -0,0 +1,228 @@
+import logging
+import win32gui
+import win32process
+import win32con
+import psutil
+from typing import List, Optional, Tuple, Dict, Any
+from .models import WindowInfo
+from .utils import setup_logger
+
+logger = setup_logger()
+
+class WindowManagerError(Exception):
+    """Base exception for WindowManager errors."""
+    pass
+
+class WindowManager:
+    """
+    Core class for managing Windows windows.
+    """
+    
+    def __init__(self):
+        """Initializes the WindowManager."""
+        self._logger = logger
+    
+    def get_all_windows(self, visible_only: bool = True) -> List[WindowInfo]:
+        """
+        Retrieves all open windows.
+        
+        Args:
+            visible_only: If True, only returns visible windows.
+            
+        Returns:
+            A list of WindowInfo objects.
+        """
+        windows: List[WindowInfo] = []
+        
+        def enum_handler(hwnd, ctx):
+            if visible_only and not win32gui.IsWindowVisible(hwnd):
+                return
+            
+            try:
+                title = win32gui.GetWindowText(hwnd)
+                class_name = win32gui.GetClassName(hwnd)
+                
+                # Get process ID
+                _, pid = win32process.GetWindowThreadProcessId(hwnd)
+                
+                # Get process name
+                try:
+                    process = psutil.Process(pid)
+                    process_name = process.name()
+                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                    process_name = "Unknown"
+                
+                # Get window rect
+                try:
+                    rect = win32gui.GetWindowRect(hwnd)
+                except Exception:
+                    rect = None
+                
+                window_info = WindowInfo(
+                    handle=hwnd,
+                    title=title,
+                    class_name=class_name,
+                    pid=pid,
+                    process_name=process_name,
+                    rect=rect,
+                    is_visible=win32gui.IsWindowVisible(hwnd)
+                )
+                windows.append(window_info)
+            except Exception as e:
+                self._logger.warning(f"Error processing window {hwnd}: {e}")
+            
+        try:
+            win32gui.EnumWindows(enum_handler, None)
+        except Exception as e:
+            self._logger.error(f"Failed to enumerate windows: {e}")
+            raise WindowManagerError(f"Failed to enumerate windows: {e}")
+            
+        return windows
+
+    def find_windows(self, title: Optional[str] = None, class_name: Optional[str] = None, process_name: Optional[str] = None, exact_match: bool = False) -> List[WindowInfo]:
+        """
+        Finds windows matching the given criteria.
+        
+        Args:
+            title: The window title to search for.
+            class_name: The window class name to search for.
+            exact_match: If True, requires exact string match. Otherwise, checks for containment.
+            
+        Returns:
+            A list of matching WindowInfo objects.
+        """
+        all_windows = self.get_all_windows(visible_only=False)
+        matched_windows = []
+        
+        for window in all_windows:
+            match = True
+            
+            if title:
+                if exact_match:
+                    if window.title != title:
+                        match = False
+                else:
+                    if title.lower() not in window.title.lower():
+                        match = False
+            
+            if match and class_name:
+                if exact_match:
+                    if window.class_name != class_name:
+                        match = False
+                else:
+                    if class_name.lower() not in window.class_name.lower():
+                        match = False
+            
+            if match and process_name:
+                if window.process_name is None or window.process_name.lower() != process_name.lower():
+                    match = False
+            
+            if match and (title or class_name or process_name):
+                matched_windows.append(window)
+                
+        return matched_windows
+
+    def get_window_by_handle(self, handle: int) -> Optional[WindowInfo]:
+        """
+        Retrieves window information by handle.
+        
+        Args:
+            handle: The window handle.
+            
+        Returns:
+            A WindowInfo object if found, otherwise None.
+        """
+        if not win32gui.IsWindow(handle):
+            return None
+            
+        try:
+            title = win32gui.GetWindowText(handle)
+            class_name = win32gui.GetClassName(handle)
+            _, pid = win32process.GetWindowThreadProcessId(handle)
+            
+            try:
+                process = psutil.Process(pid)
+                process_name = process.name()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                process_name = "Unknown"
+                
+            try:
+                rect = win32gui.GetWindowRect(handle)
+            except Exception:
+                rect = None
+
+            return WindowInfo(
+                handle=handle,
+                title=title,
+                class_name=class_name,
+                pid=pid,
+                process_name=process_name,
+                rect=rect,
+                is_visible=win32gui.IsWindowVisible(handle)
+            )
+        except Exception as e:
+            self._logger.error(f"Error getting window info for handle {handle}: {e}")
+            return None
+
+    def close_window(self, handle: int) -> bool:
+        """Closes the window with the given handle."""
+        try:
+            win32gui.PostMessage(handle, win32con.WM_CLOSE, 0, 0)
+            self._logger.info(f"Closed window {handle}")
+            return True
+        except Exception as e:
+            self._logger.error(f"Failed to close window {handle}: {e}")
+            return False
+
+    def minimize_window(self, handle: int) -> bool:
+        """Minimizes the window."""
+        try:
+            win32gui.ShowWindow(handle, win32con.SW_MINIMIZE)
+            self._logger.info(f"Minimized window {handle}")
+            return True
+        except Exception as e:
+            self._logger.error(f"Failed to minimize window {handle}: {e}")
+            return False
+
+    def maximize_window(self, handle: int) -> bool:
+        """Maximizes the window."""
+        try:
+            win32gui.ShowWindow(handle, win32con.SW_MAXIMIZE)
+            self._logger.info(f"Maximized window {handle}")
+            return True
+        except Exception as e:
+            self._logger.error(f"Failed to maximize window {handle}: {e}")
+            return False
+
+    def restore_window(self, handle: int) -> bool:
+        """Restores the window."""
+        try:
+            win32gui.ShowWindow(handle, win32con.SW_RESTORE)
+            self._logger.info(f"Restored window {handle}")
+            return True
+        except Exception as e:
+            self._logger.error(f"Failed to restore window {handle}: {e}")
+            return False
+            
+    def move_window(self, handle: int, x: int, y: int, width: int, height: int) -> bool:
+        """Moves and resizes the window."""
+        try:
+            win32gui.MoveWindow(handle, x, y, width, height, True)
+            self._logger.info(f"Moved window {handle} to ({x}, {y}, {width}, {height})")
+            return True
+        except Exception as e:
+            self._logger.error(f"Failed to move window {handle}: {e}")
+            return False
+
+    def set_foreground(self, handle: int) -> bool:
+        """Brings the window to the foreground."""
+        try:
+            # Sometimes setting foreground requires specific conditions or tricks
+            # like attaching thread input if the foreground lock timeout is set.
+            # For simplicity, we just try SetForegroundWindow.
+            win32gui.SetForegroundWindow(handle)
+            self._logger.info(f"Set window {handle} to foreground")
+            return True
+        except Exception as e:
+            self._logger.error(f"Failed to set foreground window {handle}: {e}")
+            return False

python_win_windows_manager-0.1.0/src/window_manager/models.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class WindowInfo:
+    """
+    Represents information about a window.
+    """
+    handle: int
+    title: str
+    class_name: str
+    pid: int
+    process_name: Optional[str] = None
+    rect: Optional[tuple[int, int, int, int]] = None  # (left, top, right, bottom)
+    is_visible: bool = False
+    
+    def __str__(self):
+        return (f"Window(handle={self.handle}, title='{self.title}', "
+                f"class='{self.class_name}', pid={self.pid}, "
+                f"process='{self.process_name}')")

python_win_windows_manager-0.1.0/src/window_manager/monitor.py

@@ -0,0 +1,164 @@
+import ctypes
+from ctypes import wintypes
+import threading
+import time
+import win32con
+import win32api
+import win32gui
+from typing import Callable, Optional
+from .utils import setup_logger
+
+logger = setup_logger("WindowMonitor")
+
+# Constants for SetWinEventHook
+EVENT_MIN = 0x00000001
+EVENT_MAX = 0x7FFFFFFF
+EVENT_SYSTEM_FOREGROUND = 0x0003
+EVENT_OBJECT_CREATE = 0x8000
+EVENT_OBJECT_DESTROY = 0x8001
+EVENT_OBJECT_SHOW = 0x8002
+EVENT_OBJECT_HIDE = 0x8003
+EVENT_OBJECT_NAMECHANGE = 0x800C
+WINEVENT_OUTOFCONTEXT = 0x0000
+
+# Callback function type
+WinEventProcType = ctypes.WINFUNCTYPE(
+    None,
+    wintypes.HANDLE,
+    wintypes.DWORD,
+    wintypes.HWND,
+    wintypes.LONG,
+    wintypes.LONG,
+    wintypes.DWORD,
+    wintypes.DWORD
+)
+
+user32 = ctypes.windll.user32
+
+class WindowMonitor:
+    """
+    Monitors window events such as creation, destruction, and state changes.
+    """
+    
+    def __init__(self, callback: Optional[Callable[[str, int, int], None]] = None):
+        """
+        Initializes the WindowMonitor.
+        
+        Args:
+            callback: A function to call when an event occurs. 
+                      Signature: callback(event_name, hwnd, id_object)
+        """
+        self._callback = callback
+        self._hook = None
+        self._thread = None
+        self._stop_event = threading.Event()
+        self._logger = logger
+
+    def _event_handler(self, hWinEventHook, event, hwnd, idObject, idChild, dwEventThread, dwmsEventTime):
+        """
+        Internal callback for SetWinEventHook.
+        """
+        if idObject != 0: # OBJID_WINDOW = 0
+            return
+
+        event_name = "Unknown"
+        if event == EVENT_OBJECT_CREATE:
+            event_name = "Create"
+        elif event == EVENT_OBJECT_DESTROY:
+            event_name = "Destroy"
+        elif event == EVENT_OBJECT_SHOW:
+            event_name = "Show"
+        elif event == EVENT_OBJECT_HIDE:
+            event_name = "Hide"
+        elif event == EVENT_SYSTEM_FOREGROUND:
+            event_name = "Foreground"
+        elif event == EVENT_OBJECT_NAMECHANGE:
+            event_name = "NameChange"
+        
+        # Only log/callback for interesting events on actual windows
+        # Filter out some noise if necessary, but for now report all OBJID_WINDOW
+        
+        # We can try to get window title here, but be careful as the window might be destroying
+        title = ""
+        try:
+            if event != EVENT_OBJECT_DESTROY:
+                 # win32gui.GetWindowText might fail if window is gone
+                 length = user32.GetWindowTextLengthW(hwnd)
+                 buff = ctypes.create_unicode_buffer(length + 1)
+                 user32.GetWindowTextW(hwnd, buff, length + 1)
+                 title = buff.value
+        except Exception:
+            pass
+
+        log_msg = f"Event: {event_name}, HWND: {hwnd}, Title: {title}"
+        self._logger.info(log_msg)
+        
+        if self._callback:
+            try:
+                self._callback(event_name, hwnd, title)
+            except Exception as e:
+                self._logger.error(f"Error in user callback: {e}")
+
+    def _run(self):
+        """
+        The thread function that runs the message loop.
+        """
+        self._logger.info("Starting monitor thread...")
+        
+        # Keep reference to the callback to prevent garbage collection
+        self._c_callback = WinEventProcType(self._event_handler)
+        
+        # Set hook
+        self._hook = user32.SetWinEventHook(
+            EVENT_MIN,
+            EVENT_MAX,
+            0,
+            self._c_callback,
+            0,
+            0,
+            WINEVENT_OUTOFCONTEXT
+        )
+        
+        if not self._hook:
+            self._logger.error("Failed to set win event hook")
+            return
+            
+        # Message loop
+        msg = wintypes.MSG()
+        while not self._stop_event.is_set():
+            # PeekMessage is non-blocking, so we can check stop_event
+            # But SetWinEventHook needs a message pump.
+            # GetMessage blocks.
+            # We can use MsgWaitForMultipleObjects or just PeekMessage with a sleep.
+            
+            if user32.PeekMessageW(ctypes.byref(msg), 0, 0, 0, 1): # PM_REMOVE = 1
+                if msg.message == win32con.WM_QUIT:
+                    break
+                user32.TranslateMessage(ctypes.byref(msg))
+                user32.DispatchMessageW(ctypes.byref(msg))
+            else:
+                time.sleep(0.01) # Small sleep to avoid CPU spin
+        
+        # Unhook
+        user32.UnhookWinEvent(self._hook)
+        self._logger.info("Monitor thread stopped.")
+
+    def start(self):
+        """Starts the monitoring thread."""
+        if self._thread and self._thread.is_alive():
+            self._logger.warning("Monitor already running")
+            return
+
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        """Stops the monitoring thread."""
+        if not self._thread or not self._thread.is_alive():
+            return
+            
+        self._stop_event.set()
+        self._thread.join(timeout=2)
+        if self._thread.is_alive():
+            self._logger.warning("Monitor thread did not stop gracefully")

python_win_windows_manager-0.1.0/src/window_manager/utils.py

@@ -0,0 +1,38 @@
+import logging
+import sys
+from typing import Optional
+
+def setup_logger(name: str = "WindowManager", level: int = logging.INFO, log_file: Optional[str] = None) -> logging.Logger:
+    """
+    Sets up a logger with the specified name, level, and optional file output.
+    
+    Args:
+        name: The name of the logger.
+        level: The logging level.
+        log_file: Optional path to a log file.
+        
+    Returns:
+        A configured logging.Logger instance.
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    
+    if logger.hasHandlers():
+        return logger
+        
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # File handler
+    if log_file:
+        file_handler = logging.FileHandler(log_file, encoding='utf-8')
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+        
+    return logger

python_win_windows_manager-0.1.0/tests/conftest.py

@@ -0,0 +1,4 @@
+import sys
+import os
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "../src"))

python_win_windows_manager-0.1.0/tests/test_core.py

@@ -0,0 +1,114 @@
+import pytest
+from unittest.mock import MagicMock, patch
+from window_manager import WindowManager, WindowInfo
+
+@pytest.fixture
+def mock_win32gui():
+    with patch("window_manager.core.win32gui") as mock:
+        yield mock
+
+@pytest.fixture
+def mock_win32process():
+    with patch("window_manager.core.win32process") as mock:
+        yield mock
+
+@pytest.fixture
+def mock_psutil():
+    with patch("window_manager.core.psutil") as mock:
+        yield mock
+
+@pytest.fixture
+def manager():
+    return WindowManager()
+
+def test_get_all_windows(manager, mock_win32gui, mock_win32process, mock_psutil):
+    # Setup mock data
+    mock_win32gui.IsWindowVisible.return_value = True
+    mock_win32gui.GetWindowText.return_value = "Test Window"
+    mock_win32gui.GetClassName.return_value = "TestClass"
+    mock_win32gui.GetWindowRect.return_value = (0, 0, 100, 100)
+    mock_win32process.GetWindowThreadProcessId.return_value = (0, 1234)
+    
+    mock_process = MagicMock()
+    mock_process.name.return_value = "test.exe"
+    mock_psutil.Process.return_value = mock_process
+    
+    # Simulate EnumWindows calling the callback once
+    def side_effect(callback, ctx):
+        callback(1, ctx)
+    mock_win32gui.EnumWindows.side_effect = side_effect
+    
+    windows = manager.get_all_windows()
+    
+    assert len(windows) == 1
+    assert windows[0].handle == 1
+    assert windows[0].title == "Test Window"
+    assert windows[0].class_name == "TestClass"
+    assert windows[0].pid == 1234
+    assert windows[0].process_name == "test.exe"
+
+def test_find_windows(manager, mock_win32gui, mock_win32process, mock_psutil):
+    # Setup mock data
+    mock_win32gui.IsWindowVisible.return_value = True
+    
+    def get_text(hwnd):
+        if hwnd == 1: return "Target Window"
+        if hwnd == 2: return "Other Window"
+        return ""
+    mock_win32gui.GetWindowText.side_effect = get_text
+    
+    mock_win32gui.GetClassName.return_value = "TestClass"
+    mock_win32process.GetWindowThreadProcessId.return_value = (0, 1234)
+    
+    mock_process = MagicMock()
+    mock_process.name.return_value = "test.exe"
+    mock_psutil.Process.return_value = mock_process
+    
+    def side_effect(callback, ctx):
+        callback(1, ctx)
+        callback(2, ctx)
+    mock_win32gui.EnumWindows.side_effect = side_effect
+    
+    # Test find by title
+    found = manager.find_windows(title="Target")
+    assert len(found) == 1
+    assert found[0].title == "Target Window"
+    
+    # Test find by exact title
+    found = manager.find_windows(title="Target", exact_match=True)
+    assert len(found) == 0
+    
+    found = manager.find_windows(title="Target Window", exact_match=True)
+    assert len(found) == 1
+
+    # Test find by process_name
+    found = manager.find_windows(process_name="test.exe")
+    assert len(found) == 2 # Both windows have same PID in this mock
+    
+    found = manager.find_windows(process_name="other.exe")
+    assert len(found) == 0
+
+
+def test_window_controls(manager, mock_win32gui):
+    handle = 12345
+    
+    # Close
+    manager.close_window(handle)
+    mock_win32gui.PostMessage.assert_called_with(handle, 16, 0, 0) # WM_CLOSE = 16 (0x10)
+    
+    # Minimize
+    manager.minimize_window(handle)
+    mock_win32gui.ShowWindow.assert_called_with(handle, 6) # SW_MINIMIZE = 6
+    
+    # Maximize
+    manager.maximize_window(handle)
+    mock_win32gui.ShowWindow.assert_called_with(handle, 3) # SW_MAXIMIZE = 3
+    
+    # Restore
+    manager.restore_window(handle)
+    mock_win32gui.ShowWindow.assert_called_with(handle, 9) # SW_RESTORE = 9
+    
+    # Move
+    manager.move_window(handle, 10, 20, 300, 200)
+    mock_win32gui.MoveWindow.assert_called_with(handle, 10, 20, 300, 200, True)
+

python_win_windows_manager-0.1.0/tests/test_monitor.py

@@ -0,0 +1,39 @@
+import pytest
+from unittest.mock import MagicMock, patch
+import time
+from window_manager import WindowMonitor
+
+@pytest.fixture
+def mock_user32():
+    with patch("window_manager.monitor.user32") as mock:
+        yield mock
+
+def test_monitor_lifecycle(mock_user32):
+    # Mock SetWinEventHook to return a fake hook handle
+    mock_user32.SetWinEventHook.return_value = 12345
+    mock_user32.UnhookWinEvent.return_value = 1
+    
+    # Mock PeekMessage/GetMessage behavior to avoid infinite loop or blocking
+    # We want PeekMessage to return False initially to simulate no messages
+    # Then we want the loop to exit when stop is called.
+    # The loop condition is `while not self._stop_event.is_set():`
+    # So we just need to ensure PeekMessage doesn't block or return WM_QUIT immediately unless we want to test that.
+    
+    mock_user32.PeekMessageW.return_value = 0
+    
+    monitor = WindowMonitor()
+    monitor.start()
+    
+    # Allow thread to start
+    time.sleep(0.1)
+    
+    assert monitor._thread.is_alive()
+    assert monitor._hook == 12345
+    
+    monitor.stop()
+    
+    # Allow thread to stop
+    time.sleep(0.1)
+    
+    assert not monitor._thread.is_alive()
+    mock_user32.UnhookWinEvent.assert_called_with(12345)

python_win_windows_manager-0.1.0/uv.lock

@@ -0,0 +1,128 @@
+version = 1
+revision = 3
+requires-python = ">=3.13"
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "psutil"
+version = "7.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" },
+    { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" },
+    { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" },
+    { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" },
+    { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },
+    { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
+    { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
+    { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pywin32"
+version = "311"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" },
+    { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" },
+    { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" },
+]
+
+[[package]]
+name = "window-manager"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "psutil" },
+    { name = "pywin32" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "psutil", specifier = ">=7.2.2" },
+    { name = "pywin32", specifier = ">=311" },
+]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pytest", specifier = ">=9.0.2" }]