computer-use-ootb-internal 0.0.178__py3-none-any.whl → 0.0.180__py3-none-any.whl

computer_use_ootb_internal/preparation/excel_prepare.py

@@ -0,0 +1,99 @@
+import os
+import platform
+import subprocess
+import logging
+from pathlib import Path
+import time
+
+log = logging.getLogger(__name__)
+
+def run_preparation(state):
+    """
+    Performs environment preparation specific to Excel on Windows.
+    Opens a specific template file located on the user's desktop and maximizes the window.
+    Kills existing Excel processes first.
+    """
+    if platform.system() != "Windows":
+        log.warning("Excel preparation skipped: Not running on Windows.")
+        return
+
+    log.info(f"Excel preparation: Starting on Windows platform...")
+
+    try:
+        # Determine the desktop path for Windows
+        try:
+            username = os.environ.get("USERNAME", "")
+            if not username:
+                log.error("Could not determine Windows username from environment")
+                return
+            
+            log.info(f"Using Windows username: {username}")
+            desktop_path = Path(f"C:/Users/{username}/Desktop")
+            
+            if not desktop_path.exists():
+                log.error(f"Desktop path not found at: {desktop_path}")
+                alt_path = Path(f"C:/Documents and Settings/{username}/Desktop")
+                if alt_path.exists():
+                    desktop_path = alt_path
+                    log.info(f"Using alternative desktop path: {desktop_path}")
+                else:
+                    log.error("Failed to find user's desktop directory")
+                    return
+            
+        except Exception as e:
+            log.error(f"Error determining Windows user desktop: {e}", exc_info=True)
+            return
+            
+        # Construct path to template file
+        template_file = desktop_path / "template.xlsx" # Changed extension
+        log.info(f"Looking for template file at: {template_file}")
+
+        if not template_file.exists():
+            log.error(f"Template file not found at: {template_file}")
+            return
+
+        # --- Kill existing Excel processes --- 
+        log.info("Attempting to close existing Microsoft Excel processes...")
+        try:
+            # Command to forcefully terminate Excel processes by image name
+            kill_cmd = ['taskkill', '/F', '/IM', 'EXCEL.EXE'] # Changed process name
+            kill_result = subprocess.run(kill_cmd,
+                                       capture_output=True, text=True, check=False)
+            
+            # Check taskkill result
+            if kill_result.returncode == 0:
+                log.info("Successfully sent termination signal to EXCEL.EXE processes.")
+            elif "not found" in kill_result.stderr.lower() or "not found" in kill_result.stdout.lower():
+                 log.info("No running EXCEL.EXE processes found to close.")
+            else:
+                 log.warning(f"taskkill command finished with return code {kill_result.returncode}. Output: {kill_result.stdout} Stderr: {kill_result.stderr}")
+            time.sleep(2) 
+        except FileNotFoundError:
+            log.error("Error: 'taskkill' command not found. Make sure it's in the system PATH.")
+        except Exception as e:
+            log.error(f"Error occurred while trying to close Excel: {e}", exc_info=True)
+        # --- End of kill process --- 
+
+        # Open the file with Excel maximized on Windows
+        log.info(f"Attempting to open {template_file} with Excel maximized on Windows...")
+        try:
+            # Use start command with /max flag on Windows
+            cmd = ['cmd', '/c', 'start', '/max', 'excel', str(template_file)] # Changed app name
+            # Temporarily commented out file opening
+            # result = subprocess.run(cmd, check=False, capture_output=True, text=True)
+            log.info(f"(Skipped) Would open file with command: {' '.join(cmd)}")
+            result = None # Set result to None or mock success if needed elsewhere
+
+            # if result and result.returncode == 0:
+            #     log.info(f"Successfully launched Excel maximized with {template_file}")
+            # else:
+            #     log.error(f"Error opening Excel: {result.stderr.strip() if result else 'Command not run'}")
+            #     if result and result.stdout:
+            #         log.error(f"Stdout from start command: {result.stdout.strip()}")
+        except FileNotFoundError:
+             log.error("Error: 'cmd' or 'start' command not found. Ensure system PATH is configured correctly.")
+        except Exception as e:
+            log.error(f"Exception opening Excel on Windows: {e}", exc_info=True)
+                
+    except Exception as e:
+        log.error(f"An unexpected error occurred during Excel preparation: {e}", exc_info=True) 

computer_use_ootb_internal/preparation/powerpoint_prepare.py

@@ -1,74 +1,100 @@
-import os
-import platform
-import subprocess
-import logging
-from pathlib import Path
-
-log = logging.getLogger(__name__)
-
-def run_preparation(state):
-    """
-    Performs environment preparation specific to PowerPoint on Windows.
-    Opens a specific template file located on the user's desktop and maximizes the window.
-    """
-    if platform.system() != "Windows":
-        log.warning("PowerPoint preparation skipped: Not running on Windows.")
-        return
-
-    log.info(f"PowerPoint preparation: Starting on Windows platform...")
-
-    try:
-        # Determine the desktop path for Windows
-        try:
-            username = os.environ.get("USERNAME", "")
-            if not username:
-                log.error("Could not determine Windows username from environment")
-                return
-            
-            log.info(f"Using Windows username: {username}")
-            desktop_path = Path(f"C:/Users/{username}/Desktop")
-            
-            if not desktop_path.exists():
-                log.error(f"Desktop path not found at: {desktop_path}")
-                alt_path = Path(f"C:/Documents and Settings/{username}/Desktop")
-                if alt_path.exists():
-                    desktop_path = alt_path
-                    log.info(f"Using alternative desktop path: {desktop_path}")
-                else:
-                    log.error("Failed to find user's desktop directory")
-                    return
-            
-        except Exception as e:
-            log.error(f"Error determining Windows user desktop: {e}", exc_info=True)
-            return
-            
-        # Construct path to template file
-        template_file = desktop_path / "template.pptx"
-        log.info(f"Looking for template file at: {template_file}")
-
-        if not template_file.exists():
-            log.error(f"Template file not found at: {template_file}")
-            return
-
-        # Open the file with PowerPoint maximized on Windows
-        log.info(f"Attempting to open {template_file} with PowerPoint maximized on Windows...")
-        try:
-            # Use start command with /max flag on Windows
-            cmd = ['cmd', '/c', 'start', '/max', 'powerpnt', str(template_file)]
-            result = subprocess.run(cmd, check=False, capture_output=True, text=True)
-            
-            if result.returncode == 0:
-                log.info(f"Successfully launched PowerPoint maximized with {template_file}")
-            else:
-                # Log stderr for debugging potential start command issues
-                log.error(f"Error opening PowerPoint: {result.stderr.strip()}")
-                # Also log stdout as start command might output info there
-                if result.stdout:
-                    log.error(f"Stdout from start command: {result.stdout.strip()}")
-        except FileNotFoundError:
-             log.error("Error: 'cmd' or 'start' command not found. Ensure system PATH is configured correctly.")
-        except Exception as e:
-            log.error(f"Exception opening PowerPoint on Windows: {e}", exc_info=True)
-                
-    except Exception as e:
+import os
+import platform
+import subprocess
+import logging
+from pathlib import Path
+import time
+
+log = logging.getLogger(__name__)
+
+def run_preparation(state):
+    """
+    Performs environment preparation specific to PowerPoint on Windows.
+    Opens a specific template file located on the user's desktop and maximizes the window.
+    """
+    if platform.system() != "Windows":
+        log.warning("PowerPoint preparation skipped: Not running on Windows.")
+        return
+
+    log.info(f"PowerPoint preparation: Starting on Windows platform...")
+
+    try:
+        # Determine the desktop path for Windows
+        try:
+            username = os.environ.get("USERNAME", "")
+            if not username:
+                log.error("Could not determine Windows username from environment")
+                return
+            
+            log.info(f"Using Windows username: {username}")
+            desktop_path = Path(f"C:/Users/{username}/Desktop")
+            
+            if not desktop_path.exists():
+                log.error(f"Desktop path not found at: {desktop_path}")
+                alt_path = Path(f"C:/Documents and Settings/{username}/Desktop")
+                if alt_path.exists():
+                    desktop_path = alt_path
+                    log.info(f"Using alternative desktop path: {desktop_path}")
+                else:
+                    log.error("Failed to find user's desktop directory")
+                    return
+            
+        except Exception as e:
+            log.error(f"Error determining Windows user desktop: {e}", exc_info=True)
+            return
+            
+        # Construct path to template file
+        template_file = desktop_path / "template.pptx"
+        log.info(f"Looking for template file at: {template_file}")
+
+        if not template_file.exists():
+            log.error(f"Template file not found at: {template_file}")
+            return
+
+        # --- Kill existing PowerPoint processes --- 
+        log.info("Attempting to close existing Microsoft PowerPoint processes...")
+        try:
+            # Command to forcefully terminate PowerPoint processes by image name
+            kill_cmd = ['taskkill', '/F', '/IM', 'POWERPNT.EXE']
+            kill_result = subprocess.run(kill_cmd,
+                                       capture_output=True, text=True, check=False)
+            
+            # Check taskkill result
+            if kill_result.returncode == 0:
+                log.info("Successfully sent termination signal to POWERPNT.EXE processes.")
+            elif "not found" in kill_result.stderr.lower() or "not found" in kill_result.stdout.lower():
+                 log.info("No running POWERPNT.EXE processes found to close.")
+            else:
+                 # Log potential issues if taskkill ran but didn't return 0 or expected "not found" message
+                 log.warning(f"taskkill command finished with return code {kill_result.returncode}. Output: {kill_result.stdout} Stderr: {kill_result.stderr}")
+            # Add a small delay to allow processes to close
+            time.sleep(2) 
+        except FileNotFoundError:
+            log.error("Error: 'taskkill' command not found. Make sure it's in the system PATH.")
+        except Exception as e:
+            # Catch other potential errors during taskkill execution
+            log.error(f"Error occurred while trying to close PowerPoint: {e}", exc_info=True)
+        # --- End of kill process --- 
+
+        # Open the file with PowerPoint maximized on Windows
+        log.info(f"Attempting to open {template_file} with PowerPoint maximized on Windows...")
+        try:
+            # Use start command with /max flag on Windows
+            cmd = ['cmd', '/c', 'start', '/max', 'powerpnt', str(template_file)]
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True)
+            
+            if result.returncode == 0:
+                log.info(f"Successfully launched PowerPoint maximized with {template_file}")
+            else:
+                # Log stderr for debugging potential start command issues
+                log.error(f"Error opening PowerPoint: {result.stderr.strip()}")
+                # Also log stdout as start command might output info there
+                if result.stdout:
+                    log.error(f"Stdout from start command: {result.stdout.strip()}")
+        except FileNotFoundError:
+             log.error("Error: 'cmd' or 'start' command not found. Ensure system PATH is configured correctly.")
+        except Exception as e:
+            log.error(f"Exception opening PowerPoint on Windows: {e}", exc_info=True)
+                
+    except Exception as e:
         log.error(f"An unexpected error occurred during PowerPoint preparation: {e}", exc_info=True) 

computer_use_ootb_internal/preparation/pr_prepare.py

@@ -0,0 +1,101 @@
+import os
+import platform
+import subprocess
+import logging
+from pathlib import Path
+import time
+
+log = logging.getLogger(__name__)
+
+def run_preparation(state):
+    """
+    Performs environment preparation specific to Adobe Premiere Pro on Windows.
+    Opens a specific template project file located on the user's desktop and maximizes the window.
+    Kills existing Premiere Pro processes first.
+    """
+    if platform.system() != "Windows":
+        log.warning("Premiere Pro preparation skipped: Not running on Windows.")
+        return
+
+    log.info(f"Premiere Pro preparation: Starting on Windows platform...")
+
+    try:
+        # Determine the desktop path for Windows
+        try:
+            username = os.environ.get("USERNAME", "")
+            if not username:
+                log.error("Could not determine Windows username from environment")
+                return
+            
+            log.info(f"Using Windows username: {username}")
+            desktop_path = Path(f"C:/Users/{username}/Desktop")
+            
+            if not desktop_path.exists():
+                log.error(f"Desktop path not found at: {desktop_path}")
+                alt_path = Path(f"C:/Documents and Settings/{username}/Desktop")
+                if alt_path.exists():
+                    desktop_path = alt_path
+                    log.info(f"Using alternative desktop path: {desktop_path}")
+                else:
+                    log.error("Failed to find user's desktop directory")
+                    return
+            
+        except Exception as e:
+            log.error(f"Error determining Windows user desktop: {e}", exc_info=True)
+            return
+            
+        # Construct path to template file
+        template_file = desktop_path / "template.prproj" # Changed extension
+        log.info(f"Looking for template file at: {template_file}")
+
+        if not template_file.exists():
+            log.error(f"Template file not found at: {template_file}")
+            return
+
+        # --- Kill existing Premiere Pro processes --- 
+        log.info("Attempting to close existing Adobe Premiere Pro processes...")
+        try:
+            # Command to forcefully terminate Premiere Pro processes by image name
+            # Assuming the process name includes the year for 2024 version.
+            kill_cmd = ['taskkill', '/F', '/IM', 'Adobe Premiere Pro 2024.exe'] # Updated process name
+            kill_result = subprocess.run(kill_cmd,
+                                       capture_output=True, text=True, check=False)
+            
+            # Check taskkill result
+            if kill_result.returncode == 0:
+                log.info("Successfully sent termination signal to Adobe Premiere Pro 2024.exe processes.")
+            elif "not found" in kill_result.stderr.lower() or "not found" in kill_result.stdout.lower():
+                 log.info("No running Adobe Premiere Pro 2024.exe processes found to close.")
+            else:
+                 log.warning(f"taskkill command finished with return code {kill_result.returncode}. Output: {kill_result.stdout} Stderr: {kill_result.stderr}")
+            time.sleep(2) # Increased sleep time slightly for potentially heavier app
+        except FileNotFoundError:
+            log.error("Error: 'taskkill' command not found. Make sure it's in the system PATH.")
+        except Exception as e:
+            log.error(f"Error occurred while trying to close Premiere Pro: {e}", exc_info=True)
+        # --- End of kill process --- 
+
+        # Open the file with Premiere Pro maximized on Windows
+        log.info(f"Attempting to open {template_file} with Premiere Pro maximized on Windows...")
+        try:
+            # Use start command with /max flag on Windows.
+            # Assuming the application name for start command includes the year.
+            cmd = ['cmd', '/c', 'start', '/max', '"Adobe Premiere Pro 2024"', str(template_file)] # Updated app name, kept quotes
+            # Temporarily commented out file opening
+            # result = subprocess.run(cmd, check=False, capture_output=True, text=True)
+            log.info(f"(Skipped) Would open file with command: {' '.join(cmd)}")
+            result = None # Set result to None or mock success if needed elsewhere
+            
+            # if result and result.returncode == 0:
+            #     log.info(f"Successfully launched Premiere Pro maximized with {template_file}")
+            # else:
+            #     log.error(f"Error opening Premiere Pro: {result.stderr.strip() if result else 'Command not run'}")
+            #     if result and result.stdout:
+            #         log.error(f"Stdout from start command: {result.stdout.strip()}")
+        except FileNotFoundError:
+             log.error("Error: 'cmd' or 'start' command not found. Ensure system PATH is configured correctly.")
+        except Exception as e:
+            log.error(f"Exception opening Premiere Pro on Windows: {e}", exc_info=True)
+                
+    except Exception as e:
+        log.error(f"An unexpected error occurred during Premiere Pro preparation: {e}", exc_info=True) 

computer_use_ootb_internal/preparation/star_rail_prepare.py

@@ -1,100 +1,100 @@
-# src/computer_use_ootb_internal/preparation/star_rail_prepare.py
-import time
-import platform
-import subprocess # Added for taskkill
-import pyautogui
-import webbrowser
-import logging # Use logging instead of print for better practice
-
-# Set up logging for this module if needed, or rely on root logger
-log = logging.getLogger(__name__)
-
-def run_preparation(state):
-    """
-    Performs environment preparation specific to Star Rail on Windows.
-    Closes existing Edge browsers, opens the specified URL in a new Edge instance,
-    and performs initial clicks.
-    """
-    if platform.system() != "Windows":
-        log.info("Star Rail preparation skipped: Not running on Windows.")
-        return
-
-    log.info("Star Rail preparation: Starting environment setup on Windows...")
-    url = "https://sr.mihoyo.com/cloud/#/" # Consider making this configurable later
-    browser_opened = False
-    try:
-        # Attempt to close existing Microsoft Edge processes
-        log.info("Attempting to close existing Microsoft Edge processes...")
-        try:
-            # /F forces termination, /IM specifies image name
-            result = subprocess.run(['taskkill', '/F', '/IM', 'msedge.exe'],
-                                    capture_output=True, text=True, check=False)
-            if result.returncode == 0:
-                log.info("Successfully sent termination signal to msedge.exe processes.")
-            elif "not found" in result.stderr.lower() or "not found" in result.stdout.lower():
-                 log.info("No running msedge.exe processes found to close.")
-            else:
-                 log.warning(f"taskkill command finished with return code {result.returncode}. Output: {result.stdout} Stderr: {result.stderr}")
-            time.sleep(2) # Give processes time to close
-        except FileNotFoundError:
-            log.error("Error: 'taskkill' command not found. Make sure it's in the system PATH.")
-        except Exception as e:
-            log.error(f"Error occurred while trying to close Edge: {e}", exc_info=True)
-
-        # Use only webbrowser.open
-        log.info(f"Attempting to open {url} using webbrowser.open()...")
-        if webbrowser.open(url):
-            log.info(f"Successfully requested browser to open {url} via webbrowser.open().")
-            browser_opened = True
-            # Ensure sleep time for browser load before clicks is present
-            time.sleep(5)
-        else:
-            log.warning("webbrowser.open() returned False, indicating potential failure.")
-
-        if not browser_opened:
-            log.error("Failed to confirm browser opening via webbrowser.open(). Will still attempt clicks.")
-
-        # Add pyautogui click after attempting to open the browser
-        log.info("Proceeding with pyautogui actions...")
-        time.sleep(5) # Wait time for the browser to load
-
-        # Get screen size
-        screen_width, screen_height = pyautogui.size()
-        log.info(f"Detected screen size: {screen_width}x{screen_height}")
-
-        # Calculate click coordinates based on a reference resolution (e.g., 1280x720)
-        # TODO: Make these coordinates more robust or configurable
-        click_x_1 = int(screen_width * (1036 / 1280))
-        click_y_1 = int(screen_height * (500 / 720))
-        log.info(f"Calculated click coordinates for starting the game: ({click_x_1}, {click_y_1})")
-        click_x_2 = int(screen_width * (1233 / 1280))
-        click_y_2 = int(screen_height * (30 / 720))
-        log.info(f"Calculated click coordinates for closing the browser warning: ({click_x_2}, {click_y_2})")
-
-        # Disable failsafe before clicking
-        pyautogui.FAILSAFE = False
-        log.info("PyAutoGUI failsafe temporarily disabled.")
-
-        log.info(f"Clicking at coordinates: ({click_x_1}, {click_y_1})")
-        pyautogui.click(click_x_1, click_y_1)
-        time.sleep(2)
-        pyautogui.click(click_x_1, click_y_1) # Double click?
-
-        # Press F11 to attempt fullscreen
-        log.info("Pressing F11 to enter fullscreen...")
-        time.sleep(1) # Short delay before pressing F11
-        pyautogui.press('f11')
-        time.sleep(1)
-        log.info(f"Clicking at coordinates: ({click_x_2}, {click_y_2})")
-        pyautogui.click(click_x_2, click_y_2)
-        time.sleep(1)
-        pyautogui.click(click_x_2, click_y_2)
-
-        log.info("Star Rail preparation clicks completed.")
-
-    except Exception as e:
-        log.error(f"Error during Star Rail preparation (browser/click): {e}", exc_info=True)
-    finally:
-         # Ensure failsafe is re-enabled
-         pyautogui.FAILSAFE = True
+# src/computer_use_ootb_internal/preparation/star_rail_prepare.py
+import time
+import platform
+import subprocess # Added for taskkill
+import pyautogui
+import webbrowser
+import logging # Use logging instead of print for better practice
+
+# Set up logging for this module if needed, or rely on root logger
+log = logging.getLogger(__name__)
+
+def run_preparation(state):
+    """
+    Performs environment preparation specific to Star Rail on Windows.
+    Closes existing Edge browsers, opens the specified URL in a new Edge instance,
+    and performs initial clicks.
+    """
+    if platform.system() != "Windows":
+        log.info("Star Rail preparation skipped: Not running on Windows.")
+        return
+
+    log.info("Star Rail preparation: Starting environment setup on Windows...")
+    url = "https://sr.mihoyo.com/cloud/#/" # Consider making this configurable later
+    browser_opened = False
+    try:
+        # Attempt to close existing Microsoft Edge processes
+        log.info("Attempting to close existing Microsoft Edge processes...")
+        try:
+            # /F forces termination, /IM specifies image name
+            result = subprocess.run(['taskkill', '/F', '/IM', 'msedge.exe'],
+                                    capture_output=True, text=True, check=False)
+            if result.returncode == 0:
+                log.info("Successfully sent termination signal to msedge.exe processes.")
+            elif "not found" in result.stderr.lower() or "not found" in result.stdout.lower():
+                 log.info("No running msedge.exe processes found to close.")
+            else:
+                 log.warning(f"taskkill command finished with return code {result.returncode}. Output: {result.stdout} Stderr: {result.stderr}")
+            time.sleep(2) # Give processes time to close
+        except FileNotFoundError:
+            log.error("Error: 'taskkill' command not found. Make sure it's in the system PATH.")
+        except Exception as e:
+            log.error(f"Error occurred while trying to close Edge: {e}", exc_info=True)
+
+        # Use only webbrowser.open
+        log.info(f"Attempting to open {url} using webbrowser.open()...")
+        if webbrowser.open(url):
+            log.info(f"Successfully requested browser to open {url} via webbrowser.open().")
+            browser_opened = True
+            # Ensure sleep time for browser load before clicks is present
+            time.sleep(5)
+        else:
+            log.warning("webbrowser.open() returned False, indicating potential failure.")
+
+        if not browser_opened:
+            log.error("Failed to confirm browser opening via webbrowser.open(). Will still attempt clicks.")
+
+        # Add pyautogui click after attempting to open the browser
+        log.info("Proceeding with pyautogui actions...")
+        time.sleep(5) # Wait time for the browser to load
+
+        # Get screen size
+        screen_width, screen_height = pyautogui.size()
+        log.info(f"Detected screen size: {screen_width}x{screen_height}")
+
+        # Calculate click coordinates based on a reference resolution (e.g., 1280x720)
+        # TODO: Make these coordinates more robust or configurable
+        click_x_1 = int(screen_width * (1036 / 1280))
+        click_y_1 = int(screen_height * (500 / 720))
+        log.info(f"Calculated click coordinates for starting the game: ({click_x_1}, {click_y_1})")
+        click_x_2 = int(screen_width * (1233 / 1280))
+        click_y_2 = int(screen_height * (30 / 720))
+        log.info(f"Calculated click coordinates for closing the browser warning: ({click_x_2}, {click_y_2})")
+
+        # Disable failsafe before clicking
+        pyautogui.FAILSAFE = False
+        log.info("PyAutoGUI failsafe temporarily disabled.")
+
+        log.info(f"Clicking at coordinates: ({click_x_1}, {click_y_1})")
+        pyautogui.click(click_x_1, click_y_1)
+        time.sleep(2)
+        pyautogui.click(click_x_1, click_y_1) # Double click?
+
+        # Press F11 to attempt fullscreen
+        log.info("Pressing F11 to enter fullscreen...")
+        time.sleep(1) # Short delay before pressing F11
+        pyautogui.press('f11')
+        time.sleep(1)
+        log.info(f"Clicking at coordinates: ({click_x_2}, {click_y_2})")
+        pyautogui.click(click_x_2, click_y_2)
+        time.sleep(1)
+        pyautogui.click(click_x_2, click_y_2)
+
+        log.info("Star Rail preparation clicks completed.")
+
+    except Exception as e:
+        log.error(f"Error during Star Rail preparation (browser/click): {e}", exc_info=True)
+    finally:
+         # Ensure failsafe is re-enabled
+         pyautogui.FAILSAFE = True
          log.info("PyAutoGUI failsafe re-enabled.")