oagi 0.4.0__tar.gz → 0.4.2__tar.gz

{oagi-0.4.0 → oagi-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: oagi
-Version: 0.4.0
+Version: 0.4.2
 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.0 → oagi-0.4.2}/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.0 → oagi-0.4.2}/pyproject.toml

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

{oagi-0.4.0 → oagi-0.4.2}/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,6 +97,8 @@ 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."""
@@ -94,12 +139,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:
@@ -115,6 +168,10 @@ class PyautoguiActionHandler:
                 x, y = self._parse_coords(arg)
                 pyautogui.doubleClick(x, y)
 
+            case ActionType.LEFT_TRIPLE:
+                x, y = self._parse_coords(arg)
+                pyautogui.tripleClick(x, y)
+
             case ActionType.RIGHT_SINGLE:
                 x, y = self._parse_coords(arg)
                 pyautogui.rightClick(x, y)
@@ -128,11 +185,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.0 → oagi-0.4.2}/src/oagi/types/models/action.py

@@ -14,6 +14,7 @@ from pydantic import BaseModel, Field
 class ActionType(str, Enum):
     CLICK = "click"
     LEFT_DOUBLE = "left_double"
+    LEFT_TRIPLE = "left_triple"
     RIGHT_SINGLE = "right_single"
     DRAG = "drag"
     HOTKEY = "hotkey"

{oagi-0.4.0 → oagi-0.4.2}/tests/test_async_task.py

@@ -175,7 +175,9 @@ class TestAsyncShortTask:
             )
 
             assert result is True
-            assert mock_executor.call_count == 1
+            assert (
+                mock_executor.call_count == 2
+            )  # Called for both steps including the completed one
             assert mock_image_provider.call_count == 2
 
         await task.close()

oagi-0.4.2/tests/test_pyautogui_action_handler.py

@@ -0,0 +1,251 @@
+# -----------------------------------------------------------------------------
+#  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 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.0 → oagi-0.4.2}/tests/test_short_task.py

@@ -60,7 +60,9 @@ class TestShortTaskAutoMode:
             )
 
             assert result is True
-            assert mock_executor.call_count == 2  # Called for first 2 steps
+            assert (
+                mock_executor.call_count == 3
+            )  # Called for all 3 steps including the completed one
             assert mock_image_provider.call_count == 3  # Called for all 3 steps
 
     def test_auto_mode_max_steps_reached(self, short_task, sample_llm_response):
@@ -133,7 +135,9 @@ class TestShortTaskAutoMode:
             )
 
             assert result is True
-            assert mock_executor.call_count == 0  # No actions to execute
+            assert (
+                mock_executor.call_count == 1
+            )  # Actions are executed even when task is complete
             assert mock_image_provider.call_count == 1
 
     def test_auto_mode_with_default_parameters(

{oagi-0.4.0 → oagi-0.4.2}/uv.lock

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

oagi-0.4.0/tests/test_pyautogui_action_handler.py

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

{oagi-0.4.0 → oagi-0.4.2}/src/oagi/async_short_task.py

@@ -41,14 +41,14 @@ class AsyncShortTask(AsyncTask):
             logger.debug(f"Async auto mode step {i + 1}/{max_steps}")
             image = await image_provider()
             step = await self.step(image)
+            if executor:
+                logger.debug(f"Executing {len(step.actions)} actions asynchronously")
+                await executor(step.actions)
             if step.stop:
                 logger.info(
                     f"Async auto mode completed successfully after {i + 1} steps"
                 )
                 return True
-            if executor:
-                logger.debug(f"Executing {len(step.actions)} actions asynchronously")
-                await executor(step.actions)
 
         logger.warning(
             f"Async auto mode reached max steps ({max_steps}) without completion"

{oagi-0.4.0 → oagi-0.4.2}/src/oagi/short_task.py

@@ -41,12 +41,12 @@ class ShortTask(Task):
             logger.debug(f"Auto mode step {i + 1}/{max_steps}")
             image = image_provider()
             step = self.step(image)
-            if step.stop:
-                logger.info(f"Auto mode completed successfully after {i + 1} steps")
-                return True
             if executor:
                 logger.debug(f"Executing {len(step.actions)} actions")
                 executor(step.actions)
+            if step.stop:
+                logger.info(f"Auto mode completed successfully after {i + 1} steps")
+                return True
 
         logger.warning(f"Auto mode reached max steps ({max_steps}) without completion")
         return False