optexity 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

optexity/inference/child_process.py

@@ -0,0 +1,251 @@
+import argparse
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from datetime import datetime, timedelta, timezone
+from urllib.parse import urljoin
+
+import httpx
+from fastapi import Body, FastAPI
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from uvicorn import run
+
+from optexity.inference.core.run_automation import run_automation
+from optexity.schema.inference import InferenceRequest
+from optexity.schema.task import Task
+from optexity.utils.settings import settings
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class ChildProcessIdRequest(BaseModel):
+    new_child_process_id: str
+
+
+child_process_id = None
+task_running = False
+last_task_start_time = None
+task_queue: asyncio.Queue[Task] = asyncio.Queue()
+
+
+async def task_processor():
+    """Background worker that processes tasks from the queue one at a time."""
+    global task_running
+    global last_task_start_time
+    logger.info("Task processor started")
+
+    while True:
+        try:
+            # Get next task from queue (blocks until one is available)
+            task = await task_queue.get()
+            task_running = True
+            last_task_start_time = datetime.now()
+            await run_automation(task, child_process_id)
+
+        except asyncio.CancelledError:
+            logger.info("Task processor cancelled")
+            break
+        except Exception as e:
+            logger.error(f"Error in task processor: {e}")
+        finally:
+
+            task_running = False
+
+
+async def register_with_master():
+    """Register with master on startup (handles restarts automatically)."""
+    # Get my task metadata from ECS
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.get("http://169.254.170.2/v3/task")
+        response.raise_for_status()
+        metadata = response.json()
+
+    my_task_arn = metadata["TaskARN"]
+    my_ip = metadata["Containers"][0]["Networks"][0]["IPv4Addresses"][0]
+
+    my_port = None
+    for binding in metadata["Containers"][0].get("NetworkBindings", []):
+        if binding["containerPort"] == settings.CHILD_PORT_OFFSET:
+            my_port = binding["hostPort"]
+            break
+
+    if not my_port:
+        logger.error("Could not find host port binding")
+        raise ValueError("Host port not found in metadata")
+
+    # Register with master
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(
+            f"http://{settings.SERVER_URL}/register_child",
+            json={"task_arn": my_task_arn, "private_ip": my_ip, "port": my_port},
+        )
+        response.raise_for_status()
+
+    logger.info(f"Registered with master: {response.json()}")
+
+
+def get_app_with_endpoints(is_aws: bool, child_id: int):
+    global child_process_id
+    child_process_id = child_id
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        """Lifespan context manager for startup and shutdown."""
+        # Startup
+
+        if is_aws:
+            asyncio.create_task(register_with_master())
+
+        logger.info("Registered with master")
+        asyncio.create_task(task_processor())
+        logger.info("Task processor background task started")
+        yield
+        # Shutdown (if needed in the future)
+        logger.info("Shutting down task processor")
+
+    app = FastAPI(title="Optexity Inference", lifespan=lifespan)
+
+    @app.get("/is_task_running", tags=["info"])
+    async def is_task_running():
+        """Is task running endpoint."""
+        return task_running
+
+    @app.get("/health", tags=["info"])
+    async def health():
+        """Health check endpoint."""
+        global last_task_start_time
+        if (
+            task_running
+            and last_task_start_time
+            and datetime.now() - last_task_start_time > timedelta(minutes=15)
+        ):
+            return JSONResponse(
+                status_code=503,
+                content={
+                    "status": "unhealthy",
+                    "message": "Task not finished in the last 15 minutes",
+                },
+            )
+        return JSONResponse(
+            status_code=200,
+            content={
+                "status": "healthy",
+                "task_running": task_running,
+                "queued_tasks": task_queue.qsize(),
+            },
+        )
+
+    @app.post("/set_child_process_id", tags=["info"])
+    async def set_child_process_id(request: ChildProcessIdRequest):
+        """Set child process id endpoint."""
+        global child_process_id
+        child_process_id = int(request.new_child_process_id)
+        return JSONResponse(
+            content={"success": True, "message": "Child process id has been set"},
+            status_code=200,
+        )
+
+    @app.post("/allocate_task")
+    async def allocate_task(task: Task = Body(...)):
+        """Get details of a specific task."""
+        try:
+
+            await task_queue.put(task)
+            return JSONResponse(
+                content={"success": True, "message": "Task has been allocated"},
+                status_code=202,
+            )
+        except Exception as e:
+            logger.error(f"Error allocating task {task.task_id}: {e}")
+            return JSONResponse(
+                content={"success": False, "message": str(e)}, status_code=500
+            )
+
+    if not is_aws:
+
+        @app.post("/inference")
+        async def inference(inference_request: InferenceRequest = Body(...)):
+            response_data: dict | None = None
+            try:
+
+                async with httpx.AsyncClient(timeout=30.0) as client:
+                    url = urljoin(settings.SERVER_URL, settings.INFERENCE_ENDPOINT)
+                    headers = {"x-api-key": settings.API_KEY}
+                    response = await client.post(
+                        url, json=inference_request.model_dump(), headers=headers
+                    )
+                    response_data = response.json()
+                    response.raise_for_status()
+
+                task_data = response_data["task"]
+
+                task = Task.model_validate_json(task_data)
+                if task.use_proxy and settings.PROXY_URL is None:
+                    raise ValueError(
+                        "PROXY_URL is not set and is required when use_proxy is True"
+                    )
+                task.allocated_at = datetime.now(timezone.utc)
+                await task_queue.put(task)
+
+                return JSONResponse(
+                    content={
+                        "success": True,
+                        "message": "Task has been allocated",
+                        "task_id": task.task_id,
+                    },
+                    status_code=202,
+                )
+
+            except Exception as e:
+                error = str(e)
+                if response_data is not None:
+                    error = response_data.get("error", str(e))
+
+                logger.error(f"❌ Error fetching recordings: {error}")
+                return JSONResponse({"success": False, "error": error}, status_code=500)
+
+    return app
+
+
+def main():
+    """Main function to run the server."""
+    parser = argparse.ArgumentParser(
+        description="Dynamic API endpoint generator for Optexity recordings"
+    )
+
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="Host to bind the server to (default: 0.0.0.0)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        help="Port to run the server ",
+    )
+    parser.add_argument(
+        "--child_process_id",
+        type=int,
+        help="Child process ID",
+    )
+    parser.add_argument(
+        "--is_aws",
+        action="store_true",
+        help="Is child process",
+        default=False,
+    )
+
+    args = parser.parse_args()
+
+    app = get_app_with_endpoints(is_aws=args.is_aws, child_id=args.child_process_id)
+
+    # Start the server (this is blocking and manages its own event loop)
+    logger.info(f"Starting server on {args.host}:{args.port}")
+    run(app, host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

optexity/inference/core/interaction/handle_agentic_task.py

@@ -0,0 +1,79 @@
+import logging
+
+from browser_use import Agent, BrowserSession, ChatGoogle, Tools
+
+from optexity.inference.infra.browser import Browser
+from optexity.schema.actions.interaction_action import (
+    AgenticTask,
+    CloseOverlayPopupAction,
+)
+from optexity.schema.memory import Memory
+from optexity.schema.task import Task
+
+logger = logging.getLogger(__name__)
+
+
+async def handle_agentic_task(
+    agentic_task_action: AgenticTask | CloseOverlayPopupAction,
+    task: Task,
+    memory: Memory,
+    browser: Browser,
+):
+
+    if agentic_task_action.backend == "browser_use":
+
+        if isinstance(agentic_task_action, CloseOverlayPopupAction):
+            tools = Tools(
+                exclude_actions=[
+                    "search",
+                    "navigate",
+                    "go_back",
+                    "upload_file",
+                    "scroll",
+                    "find_text",
+                    "send_keys",
+                    "evaluate",
+                    "switch",
+                    "close",
+                    "extract",
+                    "dropdown_options",
+                    "select_dropdown",
+                    "write_file",
+                    "read_file",
+                    "replace_file",
+                ]
+            )
+        else:
+            tools = Tools()
+        llm = ChatGoogle(model="gemini-flash-latest")
+        browser_session = BrowserSession(
+            cdp_url=browser.cdp_url, keep_alive=agentic_task_action.keep_alive
+        )
+
+        step_directory = (
+            task.logs_directory / f"step_{str(memory.automation_state.step_index)}"
+        )
+        step_directory.mkdir(parents=True, exist_ok=True)
+
+        agent = Agent(
+            task=agentic_task_action.task,
+            llm=llm,
+            browser_session=browser_session,
+            use_vision=agentic_task_action.use_vision,
+            tools=tools,
+            calculate_cost=True,
+            save_conversation_path=step_directory,
+        )
+        logger.debug(f"Starting browser session for agentic task {browser.cdp_url} ")
+        await agent.browser_session.start()
+        logger.debug(f"Finally running agentic task on browser_use {browser.cdp_url} ")
+        await agent.run(max_steps=agentic_task_action.max_steps)
+        logger.debug(f"Agentic task completed on browser_use {browser.cdp_url} ")
+
+        agent.stop()
+        if agent.browser_session:
+            await agent.browser_session.stop()
+            await agent.browser_session.reset()
+
+    elif agentic_task_action.backend == "browserbase":
+        raise NotImplementedError("Browserbase is not supported yet")

optexity/inference/core/interaction/handle_check.py

@@ -0,0 +1,57 @@
+import logging
+
+from optexity.inference.core.interaction.handle_command import (
+    command_based_action_with_retry,
+)
+from optexity.inference.infra.browser import Browser
+from optexity.schema.actions.interaction_action import CheckAction, UncheckAction
+from optexity.schema.memory import Memory
+from optexity.schema.task import Task
+
+logger = logging.getLogger(__name__)
+
+
+async def handle_check_element(
+    check_element_action: CheckAction,
+    task: Task,
+    memory: Memory,
+    browser: Browser,
+    max_timeout_seconds_per_try: float,
+    max_tries: int,
+):
+
+    if check_element_action.command and not check_element_action.skip_command:
+        last_error = await command_based_action_with_retry(
+            check_element_action,
+            browser,
+            memory,
+            task,
+            max_tries,
+            max_timeout_seconds_per_try,
+        )
+
+        if last_error is None:
+            return
+
+
+async def handle_uncheck_element(
+    uncheck_element_action: UncheckAction,
+    task: Task,
+    memory: Memory,
+    browser: Browser,
+    max_timeout_seconds_per_try: float,
+    max_tries: int,
+):
+
+    if uncheck_element_action.command and not uncheck_element_action.skip_command:
+        last_error = await command_based_action_with_retry(
+            uncheck_element_action,
+            browser,
+            memory,
+            task,
+            max_tries,
+            max_timeout_seconds_per_try,
+        )
+
+        if last_error is None:
+            return

optexity/inference/core/interaction/handle_click.py

@@ -0,0 +1,79 @@
+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,
+    handle_download,
+)
+from optexity.inference.infra.browser import Browser
+from optexity.schema.actions.interaction_action import ClickElementAction
+from optexity.schema.memory import Memory
+from optexity.schema.task import Task
+
+logger = logging.getLogger(__name__)
+
+
+async def handle_click_element(
+    click_element_action: ClickElementAction,
+    task: Task,
+    memory: Memory,
+    browser: Browser,
+    max_timeout_seconds_per_try: float,
+    max_tries: int,
+):
+
+    if click_element_action.command and not click_element_action.skip_command:
+        last_error = await command_based_action_with_retry(
+            click_element_action,
+            browser,
+            memory,
+            task,
+            max_tries,
+            max_timeout_seconds_per_try,
+        )
+
+        if last_error is None:
+            return
+
+    if not click_element_action.skip_prompt:
+        logger.debug(
+            f"Executing prompt-based action: {click_element_action.__class__.__name__}"
+        )
+        await click_element_index(click_element_action, browser, memory, task)
+
+
+async def click_element_index(
+    click_element_action: ClickElementAction,
+    browser: Browser,
+    memory: Memory,
+    task: Task,
+):
+
+    try:
+        index = await get_index_from_prompt(
+            memory, click_element_action.prompt_instructions, browser
+        )
+        if index is None:
+            return
+
+        async def _actual_click_element():
+            action_model = browser.backend_agent.ActionModel(
+                **{"click": {"index": index}}
+            )
+            await browser.backend_agent.multi_act([action_model])
+
+        if click_element_action.expect_download:
+            await handle_download(
+                _actual_click_element,
+                memory,
+                browser,
+                task,
+                click_element_action.download_filename,
+            )
+        else:
+            await _actual_click_element()
+    except Exception as e:
+        logger.error(f"Error in click_element_index: {e}")
+        return