oagi 0.4.1__tar.gz → 0.4.3__tar.gz

{oagi-0.4.1 → oagi-0.4.3}/.github/workflows/release.yml

@@ -32,10 +32,17 @@ jobs:
           password: ${{ secrets.PYPI_API_TOKEN }}
           # Another option: Use Trusted Publishing (recommended, no token needed)
           # Configure at: https://pypi.org/manage/project/oagi/settings/publishing/
-          
+
+      - name: Get commit message
+        id: commit_message
+        run: |
+          # Get the commit message for the tagged commit
+          echo "message<<EOF" >> $GITHUB_OUTPUT
+          git log -1 --pretty=%B >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
 
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v1
         with:
-          files: dist/*
-          generate_release_notes: true
+          body: ${{ steps.commit_message.outputs.message }}
+          files: dist/*

{oagi-0.4.1 → oagi-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: oagi
-Version: 0.4.1
+Version: 0.4.3
 Summary: Official API of OpenAGI Foundation
 Project-URL: Homepage, https://github.com/agiopen-org/oagi
 Author-email: OpenAGI Foundation <contact@agiopen.org>
@@ -93,6 +93,8 @@ config = PyautoguiConfig(
     scroll_amount=50,       # Larger scroll steps (default: 30)
     wait_duration=2.0,      # Longer waits (default: 1.0)
     action_pause=0.2,       # More pause between actions (default: 0.1)
+    hotkey_interval=0.1,    # Interval between keys in hotkey combinations (default: 0.1)
+    capslock_mode="session" # Caps lock mode: 'session' or 'system' (default: 'session')
 )
 
 executor = PyautoguiActionHandler(config=config)

{oagi-0.4.1 → oagi-0.4.3}/README.md

@@ -59,6 +59,8 @@ config = PyautoguiConfig(
     scroll_amount=50,       # Larger scroll steps (default: 30)
     wait_duration=2.0,      # Longer waits (default: 1.0)
     action_pause=0.2,       # More pause between actions (default: 0.1)
+    hotkey_interval=0.1,    # Interval between keys in hotkey combinations (default: 0.1)
+    capslock_mode="session" # Caps lock mode: 'session' or 'system' (default: 'session')
 )
 
 executor = PyautoguiActionHandler(config=config)

{oagi-0.4.1 → oagi-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "oagi"
-version = "0.4.1"
+version = "0.4.3"
 description = "Official API of OpenAGI Foundation"
 readme = "README.md"
 license = { file = "LICENSE" }

{oagi-0.4.1 → oagi-0.4.3}/src/oagi/pyautogui_action_handler.py

@@ -15,6 +15,42 @@ from pydantic import BaseModel, Field
 from .types import Action, ActionType
 
 
+class CapsLockManager:
+    """Manages caps lock state for text transformation."""
+
+    def __init__(self, mode: str = "session"):
+        """Initialize caps lock manager.
+
+        Args:
+            mode: Either "session" (internal state) or "system" (OS-level)
+        """
+        self.mode = mode
+        self.caps_enabled = False
+
+    def toggle(self):
+        """Toggle caps lock state in session mode."""
+        if self.mode == "session":
+            self.caps_enabled = not self.caps_enabled
+
+    def transform_text(self, text: str) -> str:
+        """Transform text based on caps lock state.
+
+        Args:
+            text: Input text to transform
+
+        Returns:
+            Transformed text (uppercase if caps enabled in session mode)
+        """
+        if self.mode == "session" and self.caps_enabled:
+            # Transform letters to uppercase, preserve special characters
+            return "".join(c.upper() if c.isalpha() else c for c in text)
+        return text
+
+    def should_use_system_capslock(self) -> bool:
+        """Check if system-level caps lock should be used."""
+        return self.mode == "system"
+
+
 class PyautoguiConfig(BaseModel):
     """Configuration for PyautoguiActionHandler."""
 
@@ -30,6 +66,13 @@ class PyautoguiConfig(BaseModel):
     action_pause: float = Field(
         default=0.1, description="Pause between PyAutoGUI actions in seconds"
     )
+    hotkey_interval: float = Field(
+        default=0.1, description="Interval between key presses in hotkey combinations"
+    )
+    capslock_mode: str = Field(
+        default="session",
+        description="Caps lock handling mode: 'session' (internal state) or 'system' (OS-level)",
+    )
 
 
 class PyautoguiActionHandler:
@@ -54,11 +97,30 @@ class PyautoguiActionHandler:
         self.screen_width, self.screen_height = pyautogui.size()
         # Set default delay between actions
         pyautogui.PAUSE = self.config.action_pause
+        # Initialize caps lock manager
+        self.caps_manager = CapsLockManager(mode=self.config.capslock_mode)
 
     def _denormalize_coords(self, x: float, y: float) -> tuple[int, int]:
-        """Convert coordinates from 0-1000 range to actual screen coordinates."""
+        """Convert coordinates from 0-1000 range to actual screen coordinates.
+
+        Also handles corner coordinates to prevent PyAutoGUI fail-safe trigger.
+        Corner coordinates (0,0), (0,max), (max,0), (max,max) are offset by 1 pixel.
+        """
         screen_x = int(x * self.screen_width / 1000)
         screen_y = int(y * self.screen_height / 1000)
+
+        # Prevent fail-safe by adjusting corner coordinates
+        # Check if coordinates are at screen corners (with small tolerance)
+        if screen_x < 1:
+            screen_x = 1
+        elif screen_x > self.screen_width - 1:
+            screen_x = self.screen_width - 1
+
+        if screen_y < 1:
+            screen_y = 1
+        elif screen_y > self.screen_height - 1:
+            screen_y = self.screen_height - 1
+
         return screen_x, screen_y
 
     def _parse_coords(self, args_str: str) -> tuple[int, int]:
@@ -94,12 +156,20 @@ class PyautoguiActionHandler:
         direction = match.group(3).lower()
         return x, y, direction
 
+    def _normalize_key(self, key: str) -> str:
+        """Normalize key names for consistency."""
+        key = key.strip().lower()
+        # Normalize caps lock variations
+        if key in ["caps_lock", "caps", "capslock"]:
+            return "capslock"
+        return key
+
     def _parse_hotkey(self, args_str: str) -> list[str]:
         """Parse hotkey string into list of keys."""
         # Remove parentheses if present
         args_str = args_str.strip("()")
         # Split by '+' to get individual keys
-        keys = [key.strip() for key in args_str.split("+")]
+        keys = [self._normalize_key(key) for key in args_str.split("+")]
         return keys
 
     def _execute_single_action(self, action: Action) -> None:
@@ -132,11 +202,25 @@ class PyautoguiActionHandler:
 
             case ActionType.HOTKEY:
                 keys = self._parse_hotkey(arg)
-                pyautogui.hotkey(*keys)
+                # Check if this is a caps lock key press
+                if len(keys) == 1 and keys[0] == "capslock":
+                    if self.caps_manager.should_use_system_capslock():
+                        # System mode: use OS-level caps lock
+                        pyautogui.hotkey(
+                            "capslock", interval=self.config.hotkey_interval
+                        )
+                    else:
+                        # Session mode: toggle internal state
+                        self.caps_manager.toggle()
+                else:
+                    # Regular hotkey combination
+                    pyautogui.hotkey(*keys, interval=self.config.hotkey_interval)
 
             case ActionType.TYPE:
                 # Remove quotes if present
                 text = arg.strip("\"'")
+                # Apply caps lock transformation if needed
+                text = self.caps_manager.transform_text(text)
                 pyautogui.typewrite(text)
 
             case ActionType.SCROLL:

oagi-0.4.3/tests/test_pyautogui_action_handler.py

@@ -0,0 +1,321 @@
+# -----------------------------------------------------------------------------
+#  Copyright (c) OpenAGI Foundation
+#  All rights reserved.
+#
+#  This file is part of the official API project.
+#  Licensed under the MIT License.
+# -----------------------------------------------------------------------------
+
+from unittest.mock import patch
+
+import pytest
+
+from oagi.pyautogui_action_handler import (
+    CapsLockManager,
+    PyautoguiActionHandler,
+    PyautoguiConfig,
+)
+from oagi.types import Action, ActionType
+
+
+@pytest.fixture
+def mock_pyautogui():
+    with patch("oagi.pyautogui_action_handler.pyautogui") as mock:
+        mock.size.return_value = (1920, 1080)
+        yield mock
+
+
+@pytest.fixture
+def config():
+    return PyautoguiConfig()
+
+
+@pytest.fixture
+def handler(mock_pyautogui):
+    return PyautoguiActionHandler()
+
+
+@pytest.mark.parametrize(
+    "action_type,argument,expected_method,expected_coords",
+    [
+        (ActionType.CLICK, "500, 300", "click", (960, 324)),
+        (ActionType.LEFT_DOUBLE, "400, 250", "doubleClick", (768, 270)),
+        (ActionType.LEFT_TRIPLE, "350, 200", "tripleClick", (672, 216)),
+        (ActionType.RIGHT_SINGLE, "600, 400", "rightClick", (1152, 432)),
+    ],
+)
+def test_coordinate_based_actions(
+    handler, mock_pyautogui, action_type, argument, expected_method, expected_coords
+):
+    action = Action(type=action_type, argument=argument, count=1)
+    handler([action])
+
+    getattr(mock_pyautogui, expected_method).assert_called_once_with(*expected_coords)
+
+
+def test_drag_action(handler, mock_pyautogui, config):
+    action = Action(type=ActionType.DRAG, argument="100, 100, 500, 300", count=1)
+    handler([action])
+
+    mock_pyautogui.moveTo.assert_any_call(192, 108)
+    mock_pyautogui.dragTo.assert_called_once_with(
+        960, 324, duration=config.drag_duration, button="left"
+    )
+
+
+def test_hotkey_action(handler, mock_pyautogui, config):
+    action = Action(type=ActionType.HOTKEY, argument="ctrl+c", count=1)
+    handler([action])
+
+    mock_pyautogui.hotkey.assert_called_once_with(
+        "ctrl", "c", interval=config.hotkey_interval
+    )
+
+
+def test_type_action(handler, mock_pyautogui):
+    action = Action(type=ActionType.TYPE, argument="Hello World", count=1)
+    handler([action])
+
+    mock_pyautogui.typewrite.assert_called_once_with("Hello World")
+
+
+@pytest.mark.parametrize(
+    "direction,expected_amount_multiplier",
+    [("up", 1), ("down", -1)],
+)
+def test_scroll_actions(
+    handler, mock_pyautogui, config, direction, expected_amount_multiplier
+):
+    action = Action(type=ActionType.SCROLL, argument=f"500, 300, {direction}", count=1)
+    handler([action])
+
+    mock_pyautogui.moveTo.assert_called_once_with(960, 324)
+    expected_scroll_amount = config.scroll_amount * expected_amount_multiplier
+    mock_pyautogui.scroll.assert_called_once_with(expected_scroll_amount)
+
+
+def test_wait_action(handler, mock_pyautogui, config):
+    with patch("time.sleep") as mock_sleep:
+        action = Action(type=ActionType.WAIT, argument="", count=1)
+        handler([action])
+        mock_sleep.assert_called_once_with(config.wait_duration)
+
+
+def test_hotkey_with_custom_interval(mock_pyautogui):
+    custom_config = PyautoguiConfig(hotkey_interval=0.5)
+    handler = PyautoguiActionHandler(config=custom_config)
+
+    action = Action(type=ActionType.HOTKEY, argument="cmd+shift+a", count=1)
+    handler([action])
+
+    mock_pyautogui.hotkey.assert_called_once_with("cmd", "shift", "a", interval=0.5)
+
+
+def test_finish_action(handler, mock_pyautogui):
+    action = Action(type=ActionType.FINISH, argument="", count=1)
+    handler([action])
+
+
+def test_call_user_action(handler, mock_pyautogui, capsys):
+    action = Action(type=ActionType.CALL_USER, argument="", count=1)
+    handler([action])
+
+    captured = capsys.readouterr()
+    assert "User intervention requested" in captured.out
+
+
+class TestActionExecution:
+    def test_multiple_count(self, handler, mock_pyautogui):
+        action = Action(type=ActionType.CLICK, argument="500, 300", count=3)
+        handler([action])
+
+        assert mock_pyautogui.click.call_count == 3
+
+    def test_multiple_actions(self, handler, mock_pyautogui):
+        actions = [
+            Action(type=ActionType.CLICK, argument="100, 100", count=1),
+            Action(type=ActionType.TYPE, argument="test", count=1),
+            Action(type=ActionType.HOTKEY, argument="ctrl+s", count=1),
+        ]
+        handler(actions)
+
+        mock_pyautogui.click.assert_called_once()
+        mock_pyautogui.typewrite.assert_called_once_with("test")
+        mock_pyautogui.hotkey.assert_called_once_with("ctrl", "s", interval=0.1)
+
+
+class TestInputValidation:
+    def test_invalid_coordinates_format(self, handler, mock_pyautogui):
+        action = Action(type=ActionType.CLICK, argument="invalid", count=1)
+
+        with pytest.raises(ValueError, match="Invalid coordinates format"):
+            handler([action])
+
+    def test_type_with_quotes(self, handler, mock_pyautogui):
+        action = Action(type=ActionType.TYPE, argument='"Hello World"', count=1)
+        handler([action])
+
+        mock_pyautogui.typewrite.assert_called_once_with("Hello World")
+
+
+class TestCapsLockManager:
+    def test_session_mode_text_transformation(self):
+        manager = CapsLockManager(mode="session")
+
+        # Initially caps is off
+        assert manager.transform_text("Hello World") == "Hello World"
+        assert manager.transform_text("123!@#") == "123!@#"
+
+        # Toggle caps on
+        manager.toggle()
+        assert manager.caps_enabled is True
+        assert manager.transform_text("Hello World") == "HELLO WORLD"
+        assert manager.transform_text("test123!") == "TEST123!"
+        assert manager.transform_text("123!@#") == "123!@#"
+
+        # Toggle caps off
+        manager.toggle()
+        assert manager.caps_enabled is False
+        assert manager.transform_text("Hello World") == "Hello World"
+
+    def test_system_mode_no_transformation(self):
+        manager = CapsLockManager(mode="system")
+
+        # System mode doesn't transform text
+        assert manager.transform_text("Hello World") == "Hello World"
+
+        manager.toggle()  # Should not affect state in system mode
+        assert manager.caps_enabled is False
+        assert manager.transform_text("Hello World") == "Hello World"
+
+    def test_should_use_system_capslock(self):
+        session_manager = CapsLockManager(mode="session")
+        system_manager = CapsLockManager(mode="system")
+
+        assert session_manager.should_use_system_capslock() is False
+        assert system_manager.should_use_system_capslock() is True
+
+
+class TestCornerCoordinatesHandling:
+    """Test that corner coordinates are adjusted to prevent PyAutoGUI fail-safe."""
+
+    @pytest.mark.parametrize(
+        "input_coords,expected_coords",
+        [
+            # Top-left corner
+            ("0, 0", (1, 1)),
+            ("1, 1", (1, 1)),
+            # Top-right corner (assuming 1920x1080 screen)
+            ("1000, 0", (1919, 1)),
+            ("999, 1", (1918, 1)),
+            # Bottom-left corner
+            ("0, 1000", (1, 1079)),
+            ("1, 999", (1, 1078)),
+            # Bottom-right corner
+            ("1000, 1000", (1919, 1079)),
+            ("999, 999", (1918, 1078)),
+            # Middle coordinates should not be affected
+            ("500, 500", (960, 540)),
+            ("250, 750", (480, 810)),
+        ],
+    )
+    def test_corner_coordinate_adjustment(
+        self, mock_pyautogui, input_coords, expected_coords
+    ):
+        handler = PyautoguiActionHandler()
+        action = Action(type=ActionType.CLICK, argument=input_coords, count=1)
+        handler([action])
+        mock_pyautogui.click.assert_called_once_with(*expected_coords)
+
+    def test_drag_with_corner_coordinates(self, mock_pyautogui, config):
+        """Test drag operations with corner coordinates."""
+        handler = PyautoguiActionHandler()
+        # Drag from top-left corner to bottom-right corner
+        action = Action(type=ActionType.DRAG, argument="0, 0, 1000, 1000", count=1)
+        handler([action])
+
+        # Should adjust corner coordinates to prevent fail-safe
+        mock_pyautogui.moveTo.assert_called_once_with(1, 1)
+        mock_pyautogui.dragTo.assert_called_once_with(
+            1919, 1079, duration=config.drag_duration, button="left"
+        )
+
+    def test_scroll_with_corner_coordinates(self, mock_pyautogui, config):
+        """Test scroll operations at corner coordinates."""
+        handler = PyautoguiActionHandler()
+        action = Action(type=ActionType.SCROLL, argument="0, 0, up", count=1)
+        handler([action])
+
+        # Should adjust corner coordinates
+        mock_pyautogui.moveTo.assert_called_once_with(1, 1)
+        mock_pyautogui.scroll.assert_called_once_with(config.scroll_amount)
+
+    def test_multiple_clicks_at_corners(self, mock_pyautogui):
+        """Test multiple clicks at corner positions."""
+        handler = PyautoguiActionHandler()
+        actions = [
+            Action(type=ActionType.LEFT_DOUBLE, argument="0, 0", count=1),
+            Action(type=ActionType.LEFT_TRIPLE, argument="1000, 0", count=1),
+            Action(type=ActionType.RIGHT_SINGLE, argument="0, 1000", count=1),
+        ]
+        handler(actions)
+
+        # All corner coordinates should be adjusted
+        mock_pyautogui.doubleClick.assert_called_once_with(1, 1)
+        mock_pyautogui.tripleClick.assert_called_once_with(1919, 1)
+        mock_pyautogui.rightClick.assert_called_once_with(1, 1079)
+
+
+class TestCapsLockIntegration:
+    def test_caps_lock_key_normalization(self, mock_pyautogui):
+        handler = PyautoguiActionHandler()
+
+        # Test different caps lock variations
+        for variant in ["caps", "caps_lock", "capslock"]:
+            keys = handler._parse_hotkey(variant)
+            assert keys == ["capslock"]
+
+    def test_caps_lock_session_mode(self, mock_pyautogui):
+        config = PyautoguiConfig(capslock_mode="session")
+        handler = PyautoguiActionHandler(config=config)
+
+        # Type without caps
+        type_action = Action(type=ActionType.TYPE, argument="test", count=1)
+        handler([type_action])
+        mock_pyautogui.typewrite.assert_called_with("test")
+
+        # Toggle caps lock
+        caps_action = Action(type=ActionType.HOTKEY, argument="caps_lock", count=1)
+        handler([caps_action])
+        # In session mode, should not call pyautogui.hotkey for capslock
+        assert mock_pyautogui.hotkey.call_count == 0
+
+        # Type with caps enabled
+        mock_pyautogui.typewrite.reset_mock()
+        type_action = Action(type=ActionType.TYPE, argument="test", count=1)
+        handler([type_action])
+        mock_pyautogui.typewrite.assert_called_with("TEST")
+
+    def test_caps_lock_system_mode(self, mock_pyautogui):
+        config = PyautoguiConfig(capslock_mode="system")
+        handler = PyautoguiActionHandler(config=config)
+
+        # Toggle caps lock in system mode
+        caps_action = Action(type=ActionType.HOTKEY, argument="caps", count=1)
+        handler([caps_action])
+        # In system mode, should call pyautogui.hotkey
+        mock_pyautogui.hotkey.assert_called_once_with("capslock", interval=0.1)
+
+        # Type action should not transform text in system mode
+        mock_pyautogui.typewrite.reset_mock()
+        type_action = Action(type=ActionType.TYPE, argument="test", count=1)
+        handler([type_action])
+        mock_pyautogui.typewrite.assert_called_with("test")
+
+    def test_regular_hotkey_not_affected(self, mock_pyautogui):
+        handler = PyautoguiActionHandler()
+
+        # Regular hotkeys should work normally
+        action = Action(type=ActionType.HOTKEY, argument="ctrl+c", count=1)
+        handler([action])
+        mock_pyautogui.hotkey.assert_called_once_with("ctrl", "c", interval=0.1)

{oagi-0.4.1 → oagi-0.4.3}/uv.lock

@@ -138,7 +138,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/28/fa/b2ba8229b9381e8f6
 
 [[package]]
 name = "oagi"
-version = "0.4.1"
+version = "0.4.3"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

oagi-0.4.1/tests/test_pyautogui_action_handler.py

@@ -1,144 +0,0 @@
-# -----------------------------------------------------------------------------
-#  Copyright (c) OpenAGI Foundation
-#  All rights reserved.
-#
-#  This file is part of the official API project.
-#  Licensed under the MIT License.
-# -----------------------------------------------------------------------------
-
-from unittest.mock import patch
-
-import pytest
-
-from oagi.pyautogui_action_handler import PyautoguiActionHandler, PyautoguiConfig
-from oagi.types import Action, ActionType
-
-
-@pytest.fixture
-def mock_pyautogui():
-    with patch("oagi.pyautogui_action_handler.pyautogui") as mock:
-        mock.size.return_value = (1920, 1080)
-        yield mock
-
-
-@pytest.fixture
-def config():
-    return PyautoguiConfig()
-
-
-@pytest.fixture
-def handler(mock_pyautogui):
-    return PyautoguiActionHandler()
-
-
-@pytest.mark.parametrize(
-    "action_type,argument,expected_method,expected_coords",
-    [
-        (ActionType.CLICK, "500, 300", "click", (960, 324)),
-        (ActionType.LEFT_DOUBLE, "400, 250", "doubleClick", (768, 270)),
-        (ActionType.LEFT_TRIPLE, "350, 200", "tripleClick", (672, 216)),
-        (ActionType.RIGHT_SINGLE, "600, 400", "rightClick", (1152, 432)),
-    ],
-)
-def test_coordinate_based_actions(
-    handler, mock_pyautogui, action_type, argument, expected_method, expected_coords
-):
-    action = Action(type=action_type, argument=argument, count=1)
-    handler([action])
-
-    getattr(mock_pyautogui, expected_method).assert_called_once_with(*expected_coords)
-
-
-def test_drag_action(handler, mock_pyautogui, config):
-    action = Action(type=ActionType.DRAG, argument="100, 100, 500, 300", count=1)
-    handler([action])
-
-    mock_pyautogui.moveTo.assert_any_call(192, 108)
-    mock_pyautogui.dragTo.assert_called_once_with(
-        960, 324, duration=config.drag_duration, button="left"
-    )
-
-
-@pytest.mark.parametrize(
-    "action_type,argument,expected_method,expected_args",
-    [
-        (ActionType.HOTKEY, "ctrl+c", "hotkey", ("ctrl", "c")),
-        (ActionType.TYPE, "Hello World", "typewrite", ("Hello World",)),
-    ],
-)
-def test_text_based_actions(
-    handler, mock_pyautogui, action_type, argument, expected_method, expected_args
-):
-    action = Action(type=action_type, argument=argument, count=1)
-    handler([action])
-
-    getattr(mock_pyautogui, expected_method).assert_called_once_with(*expected_args)
-
-
-@pytest.mark.parametrize(
-    "direction,expected_amount_multiplier",
-    [("up", 1), ("down", -1)],
-)
-def test_scroll_actions(
-    handler, mock_pyautogui, config, direction, expected_amount_multiplier
-):
-    action = Action(type=ActionType.SCROLL, argument=f"500, 300, {direction}", count=1)
-    handler([action])
-
-    mock_pyautogui.moveTo.assert_called_once_with(960, 324)
-    expected_scroll_amount = config.scroll_amount * expected_amount_multiplier
-    mock_pyautogui.scroll.assert_called_once_with(expected_scroll_amount)
-
-
-def test_wait_action(handler, mock_pyautogui, config):
-    with patch("time.sleep") as mock_sleep:
-        action = Action(type=ActionType.WAIT, argument="", count=1)
-        handler([action])
-        mock_sleep.assert_called_once_with(config.wait_duration)
-
-
-def test_finish_action(handler, mock_pyautogui):
-    action = Action(type=ActionType.FINISH, argument="", count=1)
-    handler([action])
-
-
-def test_call_user_action(handler, mock_pyautogui, capsys):
-    action = Action(type=ActionType.CALL_USER, argument="", count=1)
-    handler([action])
-
-    captured = capsys.readouterr()
-    assert "User intervention requested" in captured.out
-
-
-class TestActionExecution:
-    def test_multiple_count(self, handler, mock_pyautogui):
-        action = Action(type=ActionType.CLICK, argument="500, 300", count=3)
-        handler([action])
-
-        assert mock_pyautogui.click.call_count == 3
-
-    def test_multiple_actions(self, handler, mock_pyautogui):
-        actions = [
-            Action(type=ActionType.CLICK, argument="100, 100", count=1),
-            Action(type=ActionType.TYPE, argument="test", count=1),
-            Action(type=ActionType.HOTKEY, argument="ctrl+s", count=1),
-        ]
-        handler(actions)
-
-        mock_pyautogui.click.assert_called_once()
-        mock_pyautogui.typewrite.assert_called_once_with("test")
-        mock_pyautogui.hotkey.assert_called_once_with("ctrl", "s")
-
-
-class TestInputValidation:
-    def test_invalid_coordinates_format(self, handler, mock_pyautogui):
-        action = Action(type=ActionType.CLICK, argument="invalid", count=1)
-
-        with pytest.raises(ValueError, match="Invalid coordinates format"):
-            handler([action])
-
-    def test_type_with_quotes(self, handler, mock_pyautogui):
-        action = Action(type=ActionType.TYPE, argument='"Hello World"', count=1)
-        handler([action])
-
-        mock_pyautogui.typewrite.assert_called_once_with("Hello World")