optexity 0.1.5.1__py3-none-any.whl → 0.1.5.3__py3-none-any.whl

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/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/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/inference/core/interaction/handle_keypress.py

@@ -14,3 +14,29 @@ async def handle_key_press(
 
     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/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/inference/core/logging.py

@@ -364,7 +364,14 @@ async def save_latest_memory_state_locally(
             await f.write(json.dumps(task.input_parameters, indent=4))
 
         async with aiofiles.open(step_directory / "secure_parameters.json", "w") as f:
-            await f.write(json.dumps(task.secure_parameters, indent=4))
+            secure_parameters = {
+                key: [
+                    a.model_dump(exclude_none=True, exclude_defaults=True)
+                    for a in value
+                ]
+                for key, value in task.secure_parameters.items()
+            }
+            await f.write(json.dumps(secure_parameters, indent=4))
 
         async with aiofiles.open(step_directory / "generated_variables.json", "w") as f:
             await f.write(json.dumps(memory.variables.generated_variables, indent=4))

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
@@ -55,11 +54,14 @@ async def run_automation(task: Task, child_process_id: int):
     logger.info(f"Task {task.task_id} started running")
     memory = None
     browser = None
+
     try:
         await start_task_in_server(task)
         memory = Memory()
+
         browser = Browser(
             memory=memory,
+            user_data_dir=f"/tmp/userdata_{task.task_id}",
             headless=False,
             channel=task.automation.browser_channel,
             debug_port=9222 + child_process_id,
@@ -67,9 +69,12 @@ async def run_automation(task: Task, child_process_id: int):
             proxy_session_id=task.proxy_session_id(
                 settings.PROXY_PROVIDER if task.use_proxy else None
             ),
+            is_dedicated=task.is_dedicated,
         )
         await browser.start()
 
+        browser.memory = memory
+
         automation = task.automation
 
         memory.automation_state.step_index = -1
@@ -274,8 +279,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/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/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/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/inference/infra/browser.py

@@ -2,35 +2,48 @@ import asyncio
 import base64
 import json
 import logging
+import pathlib
 import re
+import shutil
 from typing import Literal
 from uuid import uuid4
 
+import patchright.async_api
+import playwright.async_api
 from browser_use import Agent, BrowserSession, ChatGoogle
 from browser_use.browser.views import BrowserStateSummary
 from patchright._impl._errors import TimeoutError as PatchrightTimeoutError
 from playwright._impl._errors import TimeoutError as PlaywrightTimeoutError
 from playwright.async_api import Download, Locator, Page, Request, Response
 
+from optexity.inference.infra.utils import _download_extension, _extract_extension
 from optexity.schema.memory import Memory, NetworkRequest, NetworkResponse
 from optexity.utils.settings import settings
 
 logger = logging.getLogger(__name__)
 
+_global_playwright: (
+    playwright.async_api.Playwright | patchright.async_api.Playwright | None
+) = None
+_global_context: (
+    playwright.async_api.BrowserContext | patchright.async_api.BrowserContext | None
+) = None
+
 
 class Browser:
     def __init__(
         self,
         memory: Memory,
-        user_data_dir: str = None,
+        user_data_dir: str,
         headless: bool = False,
-        proxy: str = None,
+        proxy: str | None = None,
         stealth: bool = True,
         backend: Literal["browser-use", "browserbase"] = "browser-use",
         debug_port: int = 9222,
         channel: Literal["chromium", "chrome"] = "chromium",
         use_proxy: bool = False,
         proxy_session_id: str | None = None,
+        is_dedicated: bool = False,
     ):
 
         if proxy:
@@ -44,9 +57,15 @@ class Browser:
         self.debug_port = debug_port
         self.use_proxy = use_proxy
         self.proxy_session_id = proxy_session_id
-        self.playwright = None
+        self.playwright: (
+            playwright.async_api.Playwright | patchright.async_api.Playwright | None
+        ) = None
         self.browser = None
-        self.context = None
+        self.context: (
+            playwright.async_api.BrowserContext
+            | patchright.async_api.BrowserContext
+            | None
+        ) = None
         self.page = None
         self.cdp_url = f"http://localhost:{self.debug_port}"
         self.backend_agent = None
@@ -54,16 +73,108 @@ class Browser:
         self.memory = memory
         self.page_to_target_id = []
         self.previous_total_pages = 0
-
+        self.is_dedicated = is_dedicated
         self.active_downloads = 0
         self.all_active_downloads_done = asyncio.Event()
         self.all_active_downloads_done.set()
 
         self.network_calls: list[NetworkResponse | NetworkRequest] = []
 
+        self.extensions = [
+            # {
+            #     "name": "optexity recorder",
+            #     "id": "pbaganbicadeoacahamnbgohafchgakp",
+            #     "url": "https://clients2.google.com/service/update2/crx?response=redirect&prodversion=133&acceptformat=crx3&x=id%3Dpbaganbicadeoacahamnbgohafchgakp%26uc",
+            # },
+            {
+                "name": "I still don't care about cookies",
+                "id": "edibdbjcniadpccecjdfdjjppcpchdlm",
+                "url": "https://clients2.google.com/service/update2/crx?response=redirect&prodversion=133&acceptformat=crx3&x=id%3Dedibdbjcniadpccecjdfdjjppcpchdlm%26uc",
+            },
+            # {
+            #     "name": "popupoff",
+            #     "id": "kiodaajmphnkcajieajajinghpejdjai",
+            #     "url": "https://clients2.google.com/service/update2/crx?response=redirect&prodversion=133&acceptformat=crx3&x=id%3Dkiodaajmphnkcajieajajinghpejdjai%26uc",
+            # },
+            {
+                "name": "ublock origin",
+                "id": "ddkjiahejlhfcafbddmgiahcphecmpfh",
+                "url": "https://clients2.google.com/service/update2/crx?response=redirect&prodversion=133&acceptformat=crx3&x=id%3Dddkjiahejlhfcafbddmgiahcphecmpfh%26uc",
+            },
+        ]
+
     async def start(self):
+        global _global_playwright, _global_context
         logger.debug("Starting browser")
         try:
+            cache_dir = pathlib.Path("/tmp/extensions")
+            cache_dir.mkdir(parents=True, exist_ok=True)
+            extension_paths = []
+            loaded_extension_names = []
+            for ext in self.extensions:
+                ext_dir = cache_dir / ext["id"]
+                crx_file = cache_dir / f'{ext["id"]}.crx'
+
+                # Check if extension is already extracted
+                if ext_dir.exists() and (ext_dir / "manifest.json").exists():
+                    logger.info(
+                        f'✅ Using cached {ext["name"]} extension from {ext_dir}'
+                    )
+                    extension_paths.append(str(ext_dir))
+                    loaded_extension_names.append(ext["name"])
+                    continue
+
+                try:
+                    # Download extension if not cached
+                    if not crx_file.exists():
+                        logger.info(f'📦 Downloading {ext["name"]} extension...')
+                        _download_extension(ext["url"], crx_file)
+                    else:
+                        logger.info(f'📦 Found cached {ext["name"]} .crx file')
+
+                    # Extract extension
+                    logger.info(f'📂 Extracting {ext["name"]} extension...')
+                    _extract_extension(crx_file, ext_dir)
+
+                    extension_paths.append(str(ext_dir))
+                    loaded_extension_names.append(ext["name"])
+                    logger.info(f'✅ Successfully loaded {ext["name"]}')
+
+                except Exception as e:
+                    logger.error(
+                        f'❌ Failed to setup {ext["name"]} extension: {e}',
+                        exc_info=True,
+                    )
+                    continue
+
+            if not extension_paths:
+                logger.error("⚠️ No extensions were loaded successfully!")
+
+            logger.info(f"Loaded extensions: {', '.join(loaded_extension_names)}")
+
+            args = [
+                "--disable-site-isolation-trials",
+                "--disable-web-security",
+                "--disable-features=IsolateOrigins,site-per-process",
+                "--allow-running-insecure-content",
+                "--ignore-certificate-errors",
+                "--ignore-ssl-errors",
+                "--ignore-certificate-errors-spki-list",
+                "--enable-extensions",
+                "--disable-extensions-file-access-check",
+                "--disable-extensions-http-throttling",
+            ]
+
+            if extension_paths:
+                disable_except = (
+                    f'--disable-extensions-except={",".join(extension_paths)}'
+                )
+                load_extension = f'--load-extension={",".join(extension_paths)}'
+                args.append(disable_except)
+                args.append(load_extension)
+                logger.info(f"Extension args: {disable_except}")
+                logger.info(f"Extension args: {load_extension}")
+
             if self.playwright is not None:
                 await self.playwright.stop()
 
@@ -98,44 +209,64 @@ class Browser:
                 if settings.PROXY_PASSWORD is not None:
                     proxy["password"] = settings.PROXY_PASSWORD
 
-            self.playwright = await async_playwright().start()
-            self.browser = await self.playwright.chromium.launch(
-                channel=self.channel,
-                headless=self.headless,
-                proxy=proxy,
-                args=[
-                    "--start-fullscreen",
-                    "--disable-popup-blocking",
-                    "--window-size=1920,1080",
-                    f"--remote-debugging-port={self.debug_port}",
-                    "--disable-gpu",
-                    "--disable-extensions",
-                    "--disable-background-networking",
-                ],
-                chromium_sandbox=False,
-            )
+            if (
+                _global_playwright is None
+                or _global_context is None
+                or not self.is_dedicated
+            ):
+                self.playwright = await async_playwright().start()
+                self.context = await self.playwright.chromium.launch_persistent_context(
+                    channel=self.channel,
+                    user_data_dir=self.user_data_dir,
+                    headless=self.headless,
+                    proxy=proxy,
+                    args=[
+                        # "--start-fullscreen",
+                        "--disable-popup-blocking",
+                        "--window-size=1920,1080",
+                        f"--remote-debugging-port={self.debug_port}",
+                        "--disable-gpu",
+                        "--disable-background-networking",
+                    ]
+                    + args,
+                    chromium_sandbox=False,
+                    no_viewport=True,
+                )
+                _global_playwright = self.playwright
+                _global_context = self.context
 
-            self.context = await self.browser.new_context(
-                no_viewport=True, ignore_https_errors=True
-            )
+                async def log_request(req: Request):
+                    await self.log_request(req)
 
-            async def log_request(req: Request):
-                await self.log_request(req)
+                async def handle_random_download(download: Download):
+                    await self.handle_random_download(download)
 
-            async def handle_random_download(download: Download):
-                await self.handle_random_download(download)
+                async def handle_random_url_downloads(resp: Response):
+                    await self.handle_random_url_downloads(resp)
 
-            async def handle_random_url_downloads(resp: Response):
-                await self.handle_random_url_downloads(resp)
+                self.context.on("request", log_request)
+                self.context.on("response", handle_random_url_downloads)
 
-            self.context.on("request", log_request)
-            self.context.on("response", handle_random_url_downloads)
+                self.context.on(
+                    "page", lambda p: (p.on("download", handle_random_download))
+                )
 
-            self.context.on(
-                "page", lambda p: (p.on("download", handle_random_download))
-            )
+            elif self.is_dedicated:
+                self.context = _global_context
+                self.playwright = _global_playwright
+                for i in range(len(self.context.pages) - 1, 0, -1):
+                    await self.context.pages[i].close()
+            else:
+                raise ValueError(
+                    "Browser is not dedicated and global playwright and context are not set"
+                )
 
-            self.page = await self.context.new_page()
+            # self.context = await self.browser.new_context(
+            #     no_viewport=True, ignore_https_errors=True
+            # )
+
+            # self.page = await self.context.new_page()
+            self.page = self.context.pages[0]
 
             browser_session = BrowserSession(cdp_url=self.cdp_url, keep_alive=True)
 
@@ -162,7 +293,7 @@ class Browser:
             raise e
 
     async def stop(self):
-        logger.debug("Stopping full system")
+        logger.debug("Stopping backend agent")
         if self.backend_agent is not None:
             logger.debug("Stopping backend agent")
             self.backend_agent.stop()
@@ -174,21 +305,25 @@ class Browser:
                 logger.debug("Browser session reset")
             self.backend_agent = None
 
-        if self.context is not None:
-            logger.debug("Stopping context")
-            await self.context.close()
-            self.context = None
-
-        if self.browser is not None:
-            logger.debug("Stopping browser")
-            await self.browser.close()
-            self.browser = None
-
-        if self.playwright is not None:
-            logger.debug("Stopping playwright")
-            await self.playwright.stop()
-            self.playwright = None
-        logger.debug("Full system stopped")
+        if not self.is_dedicated:
+            logger.debug("Stopping context and playwright and browser as not dedicated")
+            if self.context is not None:
+                logger.debug("Stopping context")
+                await self.context.close()
+                self.context = None
+
+            if self.browser is not None:
+                logger.debug("Stopping browser")
+                await self.browser.close()
+                self.browser = None
+
+            if self.playwright is not None:
+                logger.debug("Stopping playwright")
+                await self.playwright.stop()
+                self.playwright = None
+            shutil.rmtree(self.user_data_dir, ignore_errors=True)
+        else:
+            logger.debug("browser not stopped as dedicated")
 
     async def get_current_page(self) -> Page | None:
         if self.context is None:

optexity/inference/infra/utils.py

@@ -0,0 +1,98 @@
+import json
+import logging
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def _download_extension(url: str, output_path: Path) -> None:
+    """Download extension .crx file."""
+    import urllib.request
+
+    try:
+        logger.info(f"Downloading from: {url}")
+        with urllib.request.urlopen(url) as response:
+            content = response.read()
+            logger.info(f"Downloaded {len(content)} bytes")
+            with open(output_path, "wb") as f:
+                f.write(content)
+        logger.info(f"Saved to: {output_path}")
+    except Exception as e:
+        raise Exception(f"Failed to download extension: {e}")
+
+
+def _extract_extension(crx_path: Path, extract_dir: Path) -> None:
+    """Extract .crx file to directory."""
+    import os
+    import shutil
+    import zipfile
+
+    # Remove existing directory
+    if extract_dir.exists():
+        shutil.rmtree(extract_dir)
+
+    extract_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        # CRX files are ZIP files with a header, try to extract as ZIP
+        with zipfile.ZipFile(crx_path, "r") as zip_ref:
+            zip_ref.extractall(extract_dir)
+
+        # Verify manifest exists
+        if not (extract_dir / "manifest.json").exists():
+            raise Exception("No manifest.json found in extension")
+
+        logger.info("✅ Extracted as regular ZIP file")
+
+    except zipfile.BadZipFile:
+        logger.info("📦 Processing CRX header...")
+        # CRX files have a header before the ZIP data
+        with open(crx_path, "rb") as f:
+            # Read CRX header to find ZIP start
+            magic = f.read(4)
+            if magic != b"Cr24":
+                raise Exception(f"Invalid CRX file format. Magic: {magic}")
+
+            version = int.from_bytes(f.read(4), "little")
+            logger.info(f"CRX version: {version}")
+
+            if version == 2:
+                pubkey_len = int.from_bytes(f.read(4), "little")
+                sig_len = int.from_bytes(f.read(4), "little")
+                f.seek(16 + pubkey_len + sig_len)
+            elif version == 3:
+                header_len = int.from_bytes(f.read(4), "little")
+                f.seek(12 + header_len)
+            else:
+                raise Exception(f"Unsupported CRX version: {version}")
+
+            # Extract ZIP data
+            zip_data = f.read()
+            logger.info(f"ZIP data size: {len(zip_data)} bytes")
+
+        # Write ZIP data to temp file and extract
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as temp_zip:
+            temp_zip.write(zip_data)
+            temp_zip.flush()
+
+            with zipfile.ZipFile(temp_zip.name, "r") as zip_ref:
+                zip_ref.extractall(extract_dir)
+
+            os.unlink(temp_zip.name)
+
+    # Remove 'key' from manifest if present (can cause issues)
+    manifest_path = extract_dir / "manifest.json"
+    if manifest_path.exists():
+        data = json.loads(manifest_path.read_text())
+        logger.info(f"Manifest version: {data.get('manifest_version')}")
+        logger.info(f"Extension name: {data.get('name')}")
+
+        if "key" in data:
+            logger.info("Removing 'key' field from manifest")
+            del data["key"]
+            manifest_path.write_text(json.dumps(data, indent=2))
+    else:
+        raise Exception("manifest.json not found after extraction")

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/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/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/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/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
@@ -70,6 +72,7 @@ class Task(BaseModel):
     max_retries: int = 1
     api_key: str
     callback_url: CallbackUrl | None = None
+    is_dedicated: bool = False
 
     class Config:
         json_encoders = {datetime: lambda v: v.isoformat() if v is not None else None}
@@ -102,7 +105,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/utils/utils.py

@@ -3,6 +3,7 @@ import logging
 import os
 from pathlib import Path
 from typing import List, Optional
+from urllib.parse import urlparse
 
 import aiofiles
 import pyotp
@@ -74,3 +75,16 @@ async def get_onepassword_value(vault_name: str, item_name: str, field_name: str
     )
 
     return str_value
+
+
+def clean_url(url: str) -> str:
+    if not url.startswith(("http://", "https://")):
+        url = "http://" + url  # needed for urlparse
+
+    parsed = urlparse(url)
+    domain = parsed.netloc.lower()
+
+    if domain.startswith("www."):
+        domain = domain[4:]
+
+    return domain

{optexity-0.1.5.1.dist-info → optexity-0.1.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optexity
-Version: 0.1.5.1
+Version: 0.1.5.3
 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.dist-info → optexity-0.1.5.3.dist-info}/RECORD

@@ -29,52 +29,54 @@ optexity/inference/agents/two_fa_extraction/__init__.py,sha256=47DEQpj8HBSa-_TIm
 optexity/inference/agents/two_fa_extraction/prompt.py,sha256=eAqz_InZeyTnFqPMeYm-xyF7rtFWMBIF7nQW3QJnW08,1328
 optexity/inference/agents/two_fa_extraction/two_fa_extraction.py,sha256=UcBo_Iyx6Kqas-fUZpJgos5R-t2hQ2PZUFjtHmO9Rh0,1444
 optexity/inference/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-optexity/inference/core/logging.py,sha256=Zq2KL6XWlPIgsJjprxv-BLsnP5MAAKS2ciNMNkQrfBU,13870
+optexity/inference/core/logging.py,sha256=0iMJq6f2mC3xphoEbQ_LqwzwkMP96B7NKst-rW4pCyM,14129
 optexity/inference/core/run_assertion.py,sha256=cHI_A_ffe-T7XeTfTqiF3i_KIRe9ioYKSEM1rKZmq0o,2311
-optexity/inference/core/run_automation.py,sha256=8X8IEBplOjiCqv7SsUWEMEUPfwDdgUgx1eY2WWx9zms,16853
-optexity/inference/core/run_extraction.py,sha256=aA51UMU9gYMa0YD03KVf26fM5bYCrcpbf5lnmMGgjfY,7891
-optexity/inference/core/run_interaction.py,sha256=nUmlq4OfUQuTjDklngQ--EbrRZ0xSCzdbrkpLFak1R0,9341
+optexity/inference/core/run_automation.py,sha256=Xns3ic4zByRN9Owgn7cRfh-WnN_kohm2_EZMt9EVHLw,16815
+optexity/inference/core/run_extraction.py,sha256=JLdMIUM0syc3yffjkrDQ3SM2VID-tZW-Zoi7ZD3uURM,9089
+optexity/inference/core/run_interaction.py,sha256=R1llSQKAQUmll4n03x34TEBgxn5Q8jC2mborJ1EAszw,9739
 optexity/inference/core/run_python_script.py,sha256=WjnCmckZz7YmoLTGBLZeFWhhS1s_x0-kgyKYTM17JHI,547
-optexity/inference/core/run_two_fa.py,sha256=m1lxPefJHtXqMYBB0oONxd5f7XX8AI5eUkjjjs5y0Z0,4010
+optexity/inference/core/run_two_fa.py,sha256=5B3YNtLBpQYwZ73oyD2wTL-GAZMbZdMGb1csR4ApQxc,4162
 optexity/inference/core/interaction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 optexity/inference/core/interaction/handle_agentic_task.py,sha256=MSURLDM-2Hw37sipa3lqUBh1NNFrGmx2DPGJsBGYTDg,2617
 optexity/inference/core/interaction/handle_check.py,sha256=_LEA5V6h4x8fozAvPsGrFUZUaO0uU34z2R9VzGIOdio,1489
-optexity/inference/core/interaction/handle_click.py,sha256=G9ZYylql5YjHQHSuRQYXMZRK_6RI0iUwKPSTPfmXNXo,2255
-optexity/inference/core/interaction/handle_command.py,sha256=Xj7eWYoVi60tFcjseAHD33EByStiKoMsuKXaAmyVPxs,8450
+optexity/inference/core/interaction/handle_click.py,sha256=z8fvGcFY7IzMcns6Qq0br0OIW1zH66rzYtXBcAB-fP8,2425
+optexity/inference/core/interaction/handle_command.py,sha256=OIExBFmfmWGpj_fmjTrWl7Fo5dZVr0_N_lweB5oAaW8,9175
+optexity/inference/core/interaction/handle_hover.py,sha256=QpRwfDkK1P4mA5cbblgCAZpAN0v6K9XgRIe4zJ1AKRg,2591
 optexity/inference/core/interaction/handle_input.py,sha256=-Yug3fBWumCp0xQt1UVX8dqCHKs_535VheMjOHMlv2Q,2317
-optexity/inference/core/interaction/handle_keypress.py,sha256=Ig-U7qoMQ1GIaxeS2TnSTe4N3Jj64WcVc1rwl7Z-0So,466
+optexity/inference/core/interaction/handle_keypress.py,sha256=81MkFvYzAdMWgG2UvpZQJB42WeMzUHoxqeJZU4v_-CQ,1630
 optexity/inference/core/interaction/handle_select.py,sha256=z-HoFqcuvsfW_fxJrmsz9RASlqef8HA7zJUErBs-9_o,3242
-optexity/inference/core/interaction/handle_select_utils.py,sha256=gJnIvBNPFwIkFjYiaVSB-91k95leahrSnlq8fgDcWbQ,4114
+optexity/inference/core/interaction/handle_select_utils.py,sha256=1-o7t49QuNj5nENB_e2j_53j7mbaywC5lWMn55QPUZk,4498
 optexity/inference/core/interaction/handle_upload.py,sha256=Yrt9KZ-rmgJ-DK5IntIXWG-jcw7mbVYs5iSrZUMkRvc,1842
 optexity/inference/core/interaction/utils.py,sha256=_TMt0XBIIJi2K7nVQGf4PMZ-c9SCDehcMIEGPQx1GS8,2842
 optexity/inference/core/two_factor_auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 optexity/inference/infra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-optexity/inference/infra/browser.py,sha256=GpECOdxhpe5AbwU2FnRmR7jevKUiHHEZCq7PgpMI8t0,15955
+optexity/inference/infra/browser.py,sha256=NmmJjmqpQ_AITiNU1lDxAM8AaXE7obguRwPFZsSssBs,22143
 optexity/inference/infra/browser_extension.py,sha256=Ur5_8DrHcgRkD9uulDsVaaj01z1WcsvqHxHok4p4RoM,589
+optexity/inference/infra/utils.py,sha256=2BLTC93oHHKC_XDp1aas2lEeupjyHkNSMbyuKrLA418,3399
 optexity/inference/models/__init__.py,sha256=f66ea3I8ibNrkn4Uf_wYIn-2eoP-ReXds03LgaopOfA,667
 optexity/inference/models/gemini.py,sha256=ToncY6Ft4kOgIm6qREBVsScT8FG-JCrdWsBxYOgU0is,4100
 optexity/inference/models/human.py,sha256=K2X6Ohg7xeTWDYkJY6lOAwS9T3nX7YST-cvd8nL1Ydw,394
 optexity/inference/models/llm_model.py,sha256=nZvcrQs4XDI07ckFUf6o-TzvyqW-I4WIbos7WEo4hz8,7211
 optexity/schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-optexity/schema/automation.py,sha256=b-Suy9ro_bxZCIv6LU7Hnzht_DCQq-NzANqXoiuavRs,16167
+optexity/schema/automation.py,sha256=NFy6jxjXNkv4LF5sa9TH1-_ti3QARnCnsww1dsONJfg,15921
 optexity/schema/callback.py,sha256=MlN41A6oKG7QX01_w0tsxyAFKWnoCVsu_mjpWzPMYuE,519
 optexity/schema/inference.py,sha256=8mP49IRU-cRxbsC4NnoGZhd5isvdocCuMVspPBOQV9o,2864
 optexity/schema/memory.py,sha256=e3AMDAivCF_KnKbeDugqVLib8UN_6dr3ksUCiWaeIGM,3072
-optexity/schema/task.py,sha256=qv41fXKSVhxVtS5zrS9ihv35ZVZAXlbcTFO2hVrjBlc,6794
+optexity/schema/task.py,sha256=7r7MiWp9_QaS1_vQXsFlZkpMsAjSiDFNsOl4MxUFfdE,6896
 optexity/schema/token_usage.py,sha256=iwZjUqTrNhrEBMeeZNMWqD4qs2toKDczRVoDTOLLNso,2114
 optexity/schema/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 optexity/schema/actions/assertion_action.py,sha256=lcD6h7phacrEoB5j-It9qP9Ym3TKb1bkv1aa8tqwG-Q,1991
-optexity/schema/actions/extraction_action.py,sha256=-d6JaumXRZctiXNqndKE1QOWUR7fllglJ4rGuBpiVNw,4771
-optexity/schema/actions/interaction_action.py,sha256=99KuL6waCMnTB3iK6tyeatRjnIV8yhghBSLkY-_rSDo,10728
+optexity/schema/actions/extraction_action.py,sha256=s3PeaogGJA3C34R-W2kfMk0DNvUpGS0BLAfH_xdNhYA,5082
+optexity/schema/actions/interaction_action.py,sha256=9bm1FkBj2-iklClnR302Rir6d4jkgKjpZvTM2fAYn7E,11611
 optexity/schema/actions/misc_action.py,sha256=VZvaVemTlCoUwSomA42EX74L81-ICDYNWqJAuWNtyyE,312
 optexity/schema/actions/prompts.py,sha256=GZud5T2kQvQKhAXHmAnalVUP8iMcDz8be3jRp-vAInk,1772
-optexity/schema/actions/two_fa_action.py,sha256=OzzTDX3fZObWJiw8hvNgr96PBcvpDh1uONPfHrPFLf8,564
+optexity/schema/actions/two_fa_action.py,sha256=fcnuxlM3B4RguPUDw18RvMUpzLdPBRVGVC3gM_e1wLE,564
 optexity/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 optexity/utils/settings.py,sha256=h6StXzYslRgZf0c8k43-kOxoa77dOgDvSOvfQUi5yI8,1864
-optexity/utils/utils.py,sha256=QgVeKK3jAq-TLgP_RYiCXRAOEbuypFox0RxYEjruoTA,2565
-optexity-0.1.5.1.dist-info/licenses/LICENSE,sha256=WpSBqSAcwd68PmS3zRsfACJOz-u-UfTzftsEnzp4ZCY,1065
-optexity-0.1.5.1.dist-info/METADATA,sha256=ahKdSBPKViREzUaF_ufITJoaq8yytad_uKZe2kjIQ9I,9826
-optexity-0.1.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-optexity-0.1.5.1.dist-info/entry_points.txt,sha256=hcn77ooRr6a_N8fo0vij3Fpo6waqc9ijpaScQ7Kj35k,47
-optexity-0.1.5.1.dist-info/top_level.txt,sha256=OZEtBX8IabC8EnBrNW98z7NzdGQsjFhHleSthhjjEMM,9
-optexity-0.1.5.1.dist-info/RECORD,,
+optexity/utils/utils.py,sha256=4RZs_EFJlAJukYsEb-w5XgrL3VZ3rORTNF5tGSSzqBM,2883
+optexity-0.1.5.3.dist-info/licenses/LICENSE,sha256=WpSBqSAcwd68PmS3zRsfACJOz-u-UfTzftsEnzp4ZCY,1065
+optexity-0.1.5.3.dist-info/METADATA,sha256=1M6zbsuB5kWyXSHw_m0kKxZdKBlP5cfYMwCo4M1laXc,9826
+optexity-0.1.5.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+optexity-0.1.5.3.dist-info/entry_points.txt,sha256=hcn77ooRr6a_N8fo0vij3Fpo6waqc9ijpaScQ7Kj35k,47
+optexity-0.1.5.3.dist-info/top_level.txt,sha256=OZEtBX8IabC8EnBrNW98z7NzdGQsjFhHleSthhjjEMM,9
+optexity-0.1.5.3.dist-info/RECORD,,

{optexity-0.1.5.1.dist-info → optexity-0.1.5.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any