optexity 0.1.5.1__tar.gz → 0.1.5.2__tar.gz

{optexity-0.1.5.1 → optexity-0.1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optexity
-Version: 0.1.5.1
+Version: 0.1.5.2
 Summary: Optexity is a platform for building and running browser and computer agents.
 Author-email: Optexity <founders@optexity.com>
 Requires-Python: >=3.11

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/inference/core/interaction/handle_click.py

@@ -59,8 +59,11 @@ async def click_element_index(
             return
 
         async def _actual_click_element():
+            print(
+                f"Clicking element with index: {index} and button: {click_element_action.button}"
+            )
             action_model = browser.backend_agent.ActionModel(
-                **{"click": {"index": index}}
+                **{"click": {"index": index, "button": click_element_action.button}}
             )
             await browser.backend_agent.multi_act([action_model])
 

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/inference/core/interaction/handle_command.py

@@ -13,6 +13,7 @@ from optexity.inference.infra.browser import Browser
 from optexity.schema.actions.interaction_action import (
     CheckAction,
     ClickElementAction,
+    HoverAction,
     InputTextAction,
     SelectOptionAction,
     UncheckAction,
@@ -32,6 +33,7 @@ async def command_based_action_with_retry(
         | CheckAction
         | UploadFileAction
         | UncheckAction
+        | HoverAction
     ),
     browser: Browser,
     memory: Memory,
@@ -83,7 +85,7 @@ async def command_based_action_with_retry(
                     )
                 elif isinstance(action, InputTextAction):
                     await input_text_locator(
-                        action, locator, max_timeout_seconds_per_try
+                        action, locator, browser, max_timeout_seconds_per_try
                     )
                 elif isinstance(action, SelectOptionAction):
                     await select_option_locator(
@@ -102,6 +104,8 @@ async def command_based_action_with_retry(
                     await uncheck_locator(
                         action, locator, max_timeout_seconds_per_try, browser
                     )
+                elif isinstance(action, HoverAction):
+                    await hover_locator(locator, max_timeout_seconds_per_try)
                 elif isinstance(action, UploadFileAction):
                     await upload_file_locator(action, locator)
                 logger.debug(
@@ -149,7 +153,9 @@ async def click_locator(
             )
         else:
             await locator.click(
-                no_wait_after=True, timeout=max_timeout_seconds_per_try * 1000
+                button=click_element_action.button,
+                no_wait_after=True,
+                timeout=max_timeout_seconds_per_try * 1000,
             )
 
     if click_element_action.expect_download:
@@ -163,6 +169,7 @@ async def click_locator(
 async def input_text_locator(
     input_text_action: InputTextAction,
     locator: Locator,
+    browser: Browser,
     max_timeout_seconds_per_try: float,
 ):
 
@@ -172,12 +179,19 @@ async def input_text_locator(
             no_wait_after=True,
             timeout=max_timeout_seconds_per_try * 1000,
         )
-    else:
+    elif input_text_action.fill_or_type == "type":
         await locator.type(
             input_text_action.input_text,
             no_wait_after=True,
             timeout=max_timeout_seconds_per_try * 1000,
         )
+    else:
+        page = await browser.get_current_page()
+        if page is None:
+            return
+        for char in input_text_action.input_text:
+            await page.keyboard.press(char)
+            await asyncio.sleep(0.1)
 
     if input_text_action.press_enter:
         await locator.press("Enter")
@@ -211,6 +225,13 @@ async def uncheck_locator(
     )
 
 
+async def hover_locator(
+    locator: Locator,
+    max_timeout_seconds_per_try: float,
+):
+    await locator.hover(no_wait_after=True, timeout=max_timeout_seconds_per_try * 1000)
+
+
 async def upload_file_locator(upload_file_action: UploadFileAction, locator: Locator):
     await locator.set_input_files(upload_file_action.file_path)
 

optexity-0.1.5.2/optexity/inference/core/interaction/handle_hover.py

@@ -0,0 +1,83 @@
+import logging
+
+from optexity.inference.core.interaction.handle_command import (
+    command_based_action_with_retry,
+)
+from optexity.inference.core.interaction.utils import get_index_from_prompt
+from optexity.inference.infra.browser import Browser
+from optexity.schema.actions.interaction_action import HoverAction
+from optexity.schema.memory import Memory
+from optexity.schema.task import Task
+
+logger = logging.getLogger(__name__)
+
+
+async def handle_hover_element(
+    hover_element_action: HoverAction,
+    task: Task,
+    memory: Memory,
+    browser: Browser,
+    max_timeout_seconds_per_try: float,
+    max_tries: int,
+):
+
+    if hover_element_action.command and not hover_element_action.skip_command:
+        last_error = await command_based_action_with_retry(
+            hover_element_action,
+            browser,
+            memory,
+            task,
+            max_tries,
+            max_timeout_seconds_per_try,
+        )
+
+        if last_error is None:
+            return
+
+    if not hover_element_action.skip_prompt:
+        logger.debug(
+            f"Executing prompt-based action: {hover_element_action.__class__.__name__}"
+        )
+        await hover_element_index(hover_element_action, browser, memory, task)
+
+
+async def hover_element_index(
+    hover_element_action: HoverAction,
+    browser: Browser,
+    memory: Memory,
+    task: Task,
+):
+
+    try:
+        index = await get_index_from_prompt(
+            memory, hover_element_action.prompt_instructions, browser, task
+        )
+        if index is None:
+            return
+
+        print(f"Hovering element with index: {index}")
+
+        async def _actual_hover_element():
+            try:
+                action_model = browser.backend_agent.ActionModel(
+                    **{"hover": {"index": index}}
+                )
+                await browser.backend_agent.multi_act([action_model])
+            except Exception as e:
+                logger.error(f"Error in hover_element_index: {e} trying right click")
+                node = await browser.backend_agent.browser_session.get_element_by_index(
+                    index
+                )
+                if node is None:
+                    return
+
+                backend_page = (
+                    await browser.backend_agent.browser_session.get_current_page()
+                )
+                element = await backend_page.get_element(node.backend_node_id)
+                await element.click(button="right")
+
+        await _actual_hover_element()
+    except Exception as e:
+        logger.error(f"Error in hover_element_index: {e}")
+        return

optexity-0.1.5.2/optexity/inference/core/interaction/handle_keypress.py

@@ -0,0 +1,42 @@
+from optexity.inference.infra.browser import Browser
+from optexity.schema.actions.interaction_action import KeyPressAction, KeyPressType
+from optexity.schema.memory import Memory
+
+
+async def handle_key_press(
+    keypress_action: KeyPressAction,
+    memory: Memory,
+    browser: Browser,
+):
+    page = await browser.get_current_page()
+    if page is None:
+        return
+
+    if keypress_action.type == KeyPressType.ENTER:
+        await page.keyboard.press("Enter")
+    if keypress_action.type == KeyPressType.TAB:
+        await page.keyboard.press("Tab")
+    if keypress_action.type == KeyPressType.ZERO:
+        await page.keyboard.press("0")
+    if keypress_action.type == KeyPressType.ONE:
+        await page.keyboard.press("1")
+    if keypress_action.type == KeyPressType.TWO:
+        await page.keyboard.press("2")
+    if keypress_action.type == KeyPressType.THREE:
+        await page.keyboard.press("3")
+    if keypress_action.type == KeyPressType.FOUR:
+        await page.keyboard.press("4")
+    if keypress_action.type == KeyPressType.FIVE:
+        await page.keyboard.press("5")
+    if keypress_action.type == KeyPressType.SIX:
+        await page.keyboard.press("6")
+    if keypress_action.type == KeyPressType.SEVEN:
+        await page.keyboard.press("7")
+    if keypress_action.type == KeyPressType.EIGHT:
+        await page.keyboard.press("8")
+    if keypress_action.type == KeyPressType.NINE:
+        await page.keyboard.press("9")
+    if keypress_action.type == KeyPressType.SLASH:
+        await page.keyboard.press("/")
+    if keypress_action.type == KeyPressType.SPACE:
+        await page.keyboard.press("Space")

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/inference/core/interaction/handle_select_utils.py

@@ -57,9 +57,19 @@ async def smart_select(
     options: list[SelectOptionValue], patterns: list[str], memory: Memory
 ):
     # Get all options from the <select>
-
+    ## TODO: remove this once we have a better way to handle select one
     matched_values = []
 
+    if len(options) == 0:
+        return []
+    if len(options) == 1:
+        return [options[0].value]
+    if len(options) == 2 and "Select One" in [o.value for o in options]:
+        if options[0].value == "Select One":
+            return [options[1].value]
+        else:
+            return [options[0].value]
+
     for p in patterns:
         # If pattern contains regex characters, treat as regex
         is_regex = p.startswith("^") or p.endswith("$") or ".*" in p

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/inference/core/run_automation.py

@@ -25,7 +25,6 @@ from optexity.inference.core.run_interaction import (
     run_interaction_action,
 )
 from optexity.inference.core.run_python_script import run_python_script_action
-from optexity.inference.core.run_two_fa import run_two_fa_action
 from optexity.inference.infra.browser import Browser
 from optexity.schema.actions.interaction_action import DownloadUrlAsPdfAction
 from optexity.schema.automation import ActionNode, ForLoopNode, IfElseNode
@@ -274,8 +273,6 @@ async def run_action_node(
             await run_extraction_action(
                 action_node.extraction_action, memory, browser, task
             )
-        elif action_node.two_fa_action:
-            await run_two_fa_action(action_node.two_fa_action, memory)
         elif action_node.python_script_action:
             await run_python_script_action(
                 action_node.python_script_action, memory, browser

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/inference/core/run_extraction.py

@@ -4,12 +4,14 @@ import traceback
 import aiofiles
 import httpx
 
+from optexity.inference.core.run_two_fa import run_two_fa_action
 from optexity.inference.infra.browser import Browser
 from optexity.inference.models import GeminiModels, get_llm_model
 from optexity.schema.actions.extraction_action import (
     ExtractionAction,
     LLMExtraction,
     NetworkCallExtraction,
+    PythonScriptExtraction,
     ScreenshotExtraction,
     StateExtraction,
 )
@@ -51,6 +53,14 @@ async def run_extraction_action(
             task,
             extraction_action.unique_identifier,
         )
+    elif extraction_action.python_script:
+        await handle_python_script_extraction(
+            extraction_action.python_script,
+            memory,
+            browser,
+            task,
+            extraction_action.unique_identifier,
+        )
     elif extraction_action.screenshot:
         await handle_screenshot_extraction(
             extraction_action.screenshot,
@@ -65,6 +75,8 @@ async def run_extraction_action(
             browser,
             extraction_action.unique_identifier,
         )
+    elif extraction_action.two_fa_action:
+        await run_two_fa_action(extraction_action.two_fa_action, memory)
 
 
 async def handle_state_extraction(
@@ -225,6 +237,31 @@ async def handle_network_call_extraction(
             )
 
 
+async def handle_python_script_extraction(
+    python_script_extraction: PythonScriptExtraction,
+    memory: Memory,
+    browser: Browser,
+    task: Task,
+    unique_identifier: str | None = None,
+):
+    local_vars = {}
+    exec(python_script_extraction.script, {}, local_vars)
+    code_fn = local_vars["code_fn"]
+    axtree = memory.browser_states[-1].axtree
+    result = await code_fn(axtree)
+    if result is not None:
+        memory.variables.output_data.append(
+            OutputData(
+                unique_identifier=unique_identifier,
+                json_data=result,
+            )
+        )
+    else:
+        logger.warning(
+            f"No result from Python script extraction: {python_script_extraction.script}"
+        )
+
+
 async def download_request(
     network_call: NetworkRequest, download_filename: str, task: Task, memory: Memory
 ):

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/inference/core/run_interaction.py

@@ -12,6 +12,7 @@ from optexity.inference.core.interaction.handle_check import (
     handle_uncheck_element,
 )
 from optexity.inference.core.interaction.handle_click import handle_click_element
+from optexity.inference.core.interaction.handle_hover import handle_hover_element
 from optexity.inference.core.interaction.handle_input import handle_input_text
 from optexity.inference.core.interaction.handle_keypress import handle_key_press
 from optexity.inference.core.interaction.handle_select import handle_select_option
@@ -95,6 +96,15 @@ async def run_interaction_action(
                 interaction_action.max_timeout_seconds_per_try,
                 interaction_action.max_tries,
             )
+        elif interaction_action.hover:
+            await handle_hover_element(
+                interaction_action.hover,
+                task,
+                memory,
+                browser,
+                interaction_action.max_timeout_seconds_per_try,
+                interaction_action.max_tries,
+            )
         elif interaction_action.go_back:
             await handle_go_back(interaction_action.go_back, memory, browser)
         elif interaction_action.download_url_as_pdf:

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/inference/core/run_two_fa.py

@@ -33,6 +33,7 @@ async def run_two_fa_action(two_fa_action: TwoFAAction, memory: Memory):
 
     elapsed = 0
     messages = None
+    code = None
 
     while elapsed < two_fa_action.max_wait_time:
         messages = await fetch_messages(
@@ -109,12 +110,16 @@ async def fetch_messages(
             end_2fa_time=end_2fa_time,
         )
 
-    async with httpx.AsyncClient(timeout=30.0) as client:
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
 
-        response = await client.post(
-            url, json=body.model_dump(mode="json"), headers=headers
-        )
-        response.raise_for_status()
-        response_data = FetchMessagesResponse.model_validate(response.json())
+            response = await client.post(
+                url, json=body.model_dump(mode="json"), headers=headers
+            )
+            response.raise_for_status()
+            response_data = FetchMessagesResponse.model_validate(response.json())
 
-        return response_data.messages
+            return response_data.messages
+    except Exception as e:
+        logger.error(f"Error fetching messages: {e}")
+        return []

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/schema/actions/extraction_action.py

@@ -3,6 +3,7 @@ from uuid import uuid4
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
+from optexity.schema.actions.two_fa_action import TwoFAAction
 from optexity.utils.utils import build_model
 
 
@@ -53,13 +54,16 @@ class LLMExtraction(BaseModel):
         return self
 
     def replace(self, pattern: str, replacement: str):
+        self.extraction_instructions = self.extraction_instructions.replace(
+            pattern, replacement
+        )
         return self
 
 
 class NetworkCallExtraction(BaseModel):
     url_pattern: Optional[str] = None
-    extract_from: None | Literal["request", "response"] = None
-    download_from: None | Literal["request", "response"] = None
+    extract_from: None | Literal["request", "response"] = "response"
+    download_from: None | Literal["request", "response"] = "response"
     download_filename: str | None = None
 
     @model_validator(mode="before")
@@ -109,6 +113,7 @@ class ExtractionAction(BaseModel):
     python_script: Optional[PythonScriptExtraction] = None
     screenshot: Optional[ScreenshotExtraction] = None
     state: Optional[StateExtraction] = None
+    two_fa_action: TwoFAAction | None = None
 
     @model_validator(mode="after")
     def validate_one_extraction(cls, model: "ExtractionAction"):
@@ -119,12 +124,13 @@ class ExtractionAction(BaseModel):
             "python_script": model.python_script,
             "screenshot": model.screenshot,
             "state": model.state,
+            "two_fa_action": model.two_fa_action,
         }
         non_null = [k for k, v in provided.items() if v is not None]
 
         if len(non_null) != 1:
             raise ValueError(
-                "Exactly one of llm, networkcall, python_script, or screenshot must be provided"
+                "Exactly one of llm, networkcall, python_script, screenshot, state, or two_fa_action must be provided"
             )
 
         return model

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/schema/actions/interaction_action.py

@@ -1,5 +1,5 @@
 from enum import Enum, unique
-from typing import Literal
+from typing import Any, Literal
 from uuid import uuid4
 
 from pydantic import BaseModel, Field, model_validator
@@ -69,6 +69,10 @@ class UncheckAction(BaseAction):
     pass
 
 
+class HoverAction(BaseAction):
+    pass
+
+
 class SelectOptionAction(BaseAction):
     select_values: list[str]
     expect_download: bool = False
@@ -100,6 +104,7 @@ class ClickElementAction(BaseAction):
     double_click: bool = False
     expect_download: bool = False
     download_filename: str | None = None
+    button: Literal["left", "right", "middle"] = "left"
 
     @model_validator(mode="after")
     def set_download_filename(cls, model: "ClickElementAction"):
@@ -121,7 +126,7 @@ class ClickElementAction(BaseAction):
 class InputTextAction(BaseAction):
     input_text: str | None = None
     is_slider: bool = False
-    fill_or_type: Literal["fill", "type"] = "fill"
+    fill_or_type: Literal["fill", "type", "key_press"] = "fill"
     press_enter: bool = False
 
     @model_validator(mode="after")
@@ -217,10 +222,33 @@ class KeyPressType(str, Enum):
     DELETE = "Delete"
     BACKSPACE = "Backspace"
     ESCAPE = "Escape"
+    ZERO = "0"
+    ONE = "1"
+    TWO = "2"
+    THREE = "3"
+    FOUR = "4"
+    FIVE = "5"
+    SIX = "6"
+    SEVEN = "7"
+    EIGHT = "8"
+    NINE = "9"
+    SLASH = "/"
+    SPACE = "Space"
 
 
 class KeyPressAction(BaseModel):
-    type: KeyPressType
+    type: KeyPressType | Any
+
+    @model_validator(mode="after")
+    def validate_type(self):
+        if self.type is None:
+            raise ValueError("type is required")
+        return self
+
+    def replace(self, pattern: str, replacement: str):
+        if self.type:
+            self.type = self.type.replace(pattern, replacement).strip('"')
+        return self
 
 
 class AgenticTask(BaseModel):
@@ -252,6 +280,7 @@ class InteractionAction(BaseModel):
     select_option: SelectOptionAction | None = None
     check: CheckAction | None = None
     uncheck: UncheckAction | None = None
+    hover: HoverAction | None = None
     download_url_as_pdf: DownloadUrlAsPdfAction | None = None
     scroll: ScrollAction | None = None
     upload_file: UploadFileAction | None = None
@@ -274,6 +303,7 @@ class InteractionAction(BaseModel):
             "select_option": model.select_option,
             "check": model.check,
             "uncheck": model.uncheck,
+            "hover": model.hover,
             "download_url_as_pdf": model.download_url_as_pdf,
             "scroll": model.scroll,
             "upload_file": model.upload_file,
@@ -291,7 +321,7 @@ class InteractionAction(BaseModel):
 
         if len(non_null) != 1:
             raise ValueError(
-                "Exactly one of click_element, input_text, select_option, check, uncheck, download_url_as_pdf, scroll, upload_file, go_to_url, go_back, switch_tab, close_current_tab, close_all_but_last_tab, close_tabs_until, key_press, or agentic_task must be provided"
+                "Exactly one of click_element, input_text, select_option, check, uncheck, hover, download_url_as_pdf, scroll, upload_file, go_to_url, go_back, switch_tab, close_current_tab, close_all_but_last_tab, close_tabs_until, key_press, or agentic_task must be provided"
             )
 
         if (
@@ -314,6 +344,8 @@ class InteractionAction(BaseModel):
             self.check.replace(pattern, replacement)
         if self.uncheck:
             self.uncheck.replace(pattern, replacement)
+        if self.hover:
+            self.hover.replace(pattern, replacement)
         if self.download_url_as_pdf:
             self.download_url_as_pdf.replace(pattern, replacement)
         if self.close_tabs_until:
@@ -326,5 +358,7 @@ class InteractionAction(BaseModel):
             self.go_to_url.replace(pattern, replacement)
         if self.upload_file:
             self.upload_file.replace(pattern, replacement)
+        if self.key_press:
+            self.key_press.replace(pattern, replacement)
 
         return self

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/schema/actions/two_fa_action.py

@@ -21,4 +21,4 @@ class TwoFAAction(BaseModel):
     instructions: str | None = None
     output_variable_name: str
     max_wait_time: float = 300.0
-    check_interval: float = 10.0
+    check_interval: float = 30.0

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/schema/automation.py

@@ -7,7 +7,6 @@ from optexity.schema.actions.assertion_action import AssertionAction
 from optexity.schema.actions.extraction_action import ExtractionAction
 from optexity.schema.actions.interaction_action import InteractionAction
 from optexity.schema.actions.misc_action import PythonScriptAction
-from optexity.schema.actions.two_fa_action import TwoFAAction
 from optexity.utils.utils import get_onepassword_value, get_totp_code
 
 logger = logging.getLogger(__name__)
@@ -68,7 +67,6 @@ class ActionNode(BaseModel):
     assertion_action: AssertionAction | None = None
     extraction_action: ExtractionAction | None = None
     python_script_action: PythonScriptAction | None = None
-    two_fa_action: TwoFAAction | None = None
     before_sleep_time: float = 0.0
     end_sleep_time: float = 5.0
     expect_new_tab: bool = False
@@ -83,13 +81,12 @@ class ActionNode(BaseModel):
             "assertion_action": model.assertion_action,
             "extraction_action": model.extraction_action,
             "python_script_action": model.python_script_action,
-            "two_fa_action": model.two_fa_action,
         }
         non_null = [k for k, v in provided.items() if v is not None]
 
         if len(non_null) != 1:
             raise ValueError(
-                "Exactly one of interaction_action, assertion_action, extraction_action, python_script_action, or two_fa_action must be provided"
+                "Exactly one of interaction_action, assertion_action, extraction_action, python_script_action must be provided"
             )
 
         assert (
@@ -104,7 +101,7 @@ class ActionNode(BaseModel):
         user_set = model.__pydantic_fields_set__
 
         if "end_sleep_time" not in user_set:
-            if model.assertion_action or model.extraction_action or model.two_fa_action:
+            if model.assertion_action or model.extraction_action:
                 model.end_sleep_time = 0.0
 
         if "before_sleep_time" not in user_set:
@@ -130,8 +127,6 @@ class ActionNode(BaseModel):
             self.extraction_action.replace(pattern, replacement)
         if self.python_script_action:
             pass
-        if self.two_fa_action:
-            pass
 
         return self
 

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity/schema/task.py

@@ -60,7 +60,9 @@ class Task(BaseModel):
     started_at: Optional[datetime] = None
     completed_at: Optional[datetime] = None
     error: Optional[str] = None
-    status: Literal["queued", "allocated", "running", "success", "failed", "cancelled"]
+    status: Literal[
+        "queued", "allocated", "running", "success", "failed", "cancelled", "killed"
+    ]
     is_cloud: bool = False
     save_directory: Path = Field(default=Path("/tmp/optexity"))
     use_proxy: bool = False
@@ -102,7 +104,9 @@ class Task(BaseModel):
                 unique_parameter_name: self.input_parameters[unique_parameter_name]
                 for unique_parameter_name in self.unique_parameter_names
             }
-            self.dedup_key = json.dumps(self.unique_parameters, sort_keys=True)
+            self.dedup_key = (
+                json.dumps(self.unique_parameters, sort_keys=True) + self.user_id
+            )
 
         for a, b in [
             (self.automation.parameters.input_parameters, self.input_parameters),

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optexity
-Version: 0.1.5.1
+Version: 0.1.5.2
 Summary: Optexity is a platform for building and running browser and computer agents.
 Author-email: Optexity <founders@optexity.com>
 Requires-Python: >=3.11

{optexity-0.1.5.1 → optexity-0.1.5.2}/optexity.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ optexity/inference/core/interaction/handle_agentic_task.py
 optexity/inference/core/interaction/handle_check.py
 optexity/inference/core/interaction/handle_click.py
 optexity/inference/core/interaction/handle_command.py
+optexity/inference/core/interaction/handle_hover.py
 optexity/inference/core/interaction/handle_input.py
 optexity/inference/core/interaction/handle_keypress.py
 optexity/inference/core/interaction/handle_select.py

{optexity-0.1.5.1 → optexity-0.1.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "optexity"
-version = "0.1.5.1"
+version = "0.1.5.2"
 readme = "README.md"
 description = "Optexity is a platform for building and running browser and computer agents."
 authors = [{ name = "Optexity", email = "founders@optexity.com" }]

optexity-0.1.5.1/optexity/inference/core/interaction/handle_keypress.py

@@ -1,16 +0,0 @@
-from optexity.inference.infra.browser import Browser
-from optexity.schema.actions.interaction_action import KeyPressAction, KeyPressType
-from optexity.schema.memory import Memory
-
-
-async def handle_key_press(
-    keypress_action: KeyPressAction,
-    memory: Memory,
-    browser: Browser,
-):
-    page = await browser.get_current_page()
-    if page is None:
-        return
-
-    if keypress_action.type == KeyPressType.ENTER:
-        await page.keyboard.press("Enter")