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

optexity/schema/task.py

@@ -0,0 +1,212 @@
+import base64
+import json
+import string
+import uuid
+from datetime import datetime
+from io import BytesIO
+from pathlib import Path
+from typing import Literal, Optional
+
+from PIL import Image
+from pydantic import BaseModel, Field, computed_field, model_validator
+
+from optexity.schema.automation import Automation, SecureParameter
+from optexity.schema.memory import ForLoopStatus
+from optexity.schema.token_usage import TokenUsage
+
+BASE62 = string.digits + string.ascii_lowercase + string.ascii_uppercase
+
+
+def uuid_str_to_base62(uuid_str: str) -> str:
+    n = uuid.UUID(uuid_str).int
+    out = []
+    while n:
+        n, r = divmod(n, 62)
+        out.append(BASE62[r])
+    return "".join(reversed(out))
+
+
+class CallbackUrl(BaseModel):
+    url: str
+    api_key: str | None = None
+    username: str | None = None
+    password: str | None = None
+
+    @model_validator(mode="after")
+    def validate_callback_url(self):
+
+        if self.api_key is not None and (
+            self.username is not None or self.password is not None
+        ):
+            raise ValueError(
+                "api_key and username/password cannot be used together. Please provide only one of them."
+            )
+
+        return self
+
+
+class Task(BaseModel):
+    task_id: str
+    user_id: str
+    recording_id: str
+    endpoint_name: str
+    automation: Automation
+    input_parameters: dict[str, list[str | int | float | bool]]
+    secure_parameters: dict[str, list[SecureParameter]]
+    unique_parameter_names: list[str]
+    unique_parameters: dict[str, list[str]] | None = None
+    created_at: datetime
+    allocated_at: Optional[datetime] = None
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    error: Optional[str] = None
+    status: Literal["queued", "allocated", "running", "success", "failed", "cancelled"]
+    is_cloud: bool = False
+    save_directory: Path = Field(default=Path("/tmp/optexity"))
+    use_proxy: bool = False
+
+    dedup_key: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    retry_count: int = 0
+    max_retries: int = 1
+    api_key: str
+    callback_url: CallbackUrl | None = None
+
+    class Config:
+        json_encoders = {datetime: lambda v: v.isoformat() if v is not None else None}
+
+    @computed_field
+    @property
+    def task_directory(self) -> Path:
+        return self.save_directory / str(self.task_id)
+
+    @computed_field
+    @property
+    def logs_directory(self) -> Path:
+        return self.task_directory / "logs"
+
+    @computed_field
+    @property
+    def downloads_directory(self) -> Path:
+        return self.task_directory / "downloads"
+
+    @computed_field
+    @property
+    def log_file_path(self) -> Path:
+        return self.logs_directory / "optexity.log"
+
+    @model_validator(mode="after")
+    def validate_unique_parameters(self):
+        ## TODO: we do not do dedup using secure parameters yet, need to add support for that
+        if len(self.unique_parameter_names) > 0:
+            self.unique_parameters = {
+                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)
+
+        for a, b in [
+            (self.automation.parameters.input_parameters, self.input_parameters),
+            (self.automation.parameters.secure_parameters, self.secure_parameters),
+        ]:
+            if a.keys() != b.keys():
+                missing_keys = a.keys() - b.keys()
+                extra_keys = b.keys() - a.keys()
+                raise ValueError(
+                    f"Please provide exactly the same {a} as the automation. Missing keys: {missing_keys}, Extra keys: {extra_keys}"
+                )
+
+        return self
+
+    @model_validator(mode="after")
+    def set_dependent_paths(self):
+
+        self.logs_directory.mkdir(parents=True, exist_ok=True)
+        self.downloads_directory.mkdir(parents=True, exist_ok=True)
+        self.log_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        return self
+
+    def proxy_session_id(
+        self, proxy_provider: Literal["oxylabs", "other"] | None
+    ) -> str | None:
+        if not self.use_proxy:
+            return None
+        if proxy_provider == "oxylabs":
+            return uuid_str_to_base62(self.task_id)
+        else:
+            return "default"
+
+
+class TaskCreateRequest(BaseModel):
+    task_id: str
+    recording_id: str
+    input_parameters: dict
+    unique_parameter_names: list[str]
+    created_at: datetime
+
+    @model_validator(mode="after")
+    def must_have_timezone(self):
+        if self.created_at.tzinfo is None:
+            raise ValueError("created_at must include timezone information")
+
+        for unique_parameter_name in self.unique_parameter_names:
+            if unique_parameter_name not in self.input_parameters:
+                raise ValueError(
+                    f"unique_parameter_name {unique_parameter_name} not found in input_parameters"
+                )
+        return self
+
+
+class TaskStartedRequest(BaseModel):
+    task_id: str
+    started_at: datetime
+    allocated_at: Optional[datetime] = None
+
+    @model_validator(mode="after")
+    def must_have_timezone(self):
+        if self.started_at.tzinfo is None:
+            raise ValueError("started_at must include timezone information")
+        if self.allocated_at is not None and self.allocated_at.tzinfo is None:
+            raise ValueError("allocated_at must include timezone information")
+        return self
+
+
+class TaskCompleteRequest(BaseModel):
+    task_id: str
+    child_process_id: int
+
+    status: Literal["success", "failed", "cancelled"]
+    error: str | None
+    completed_at: datetime
+    token_usage: TokenUsage
+
+    @model_validator(mode="after")
+    def must_have_timezone(self):
+        if self.completed_at.tzinfo is None:
+            raise ValueError("completed_at must include timezone information")
+        return self
+
+
+class TaskOutputDataRequest(BaseModel):
+    task_id: str
+    output_data: list[dict]
+    final_screenshot: str | None
+    for_loop_status: list[list[ForLoopStatus]] | None = None
+
+    @model_validator(mode="after")
+    def must_have_valid_final_screenshot(self):
+        if self.final_screenshot is not None and not self.is_valid_base64_image(
+            self.final_screenshot
+        ):
+            raise ValueError("final_screenshot must be a valid base64 encoded image")
+        return self
+
+    def is_valid_base64_image(self, data: str) -> bool:
+        try:
+            # Decode the base64 string
+            decoded = base64.b64decode(data, validate=True)
+            # Try to open it as an image
+            Image.open(BytesIO(decoded))
+            return True
+        except Exception as e:
+            return False

optexity/schema/token_usage.py

@@ -0,0 +1,48 @@
+from pydantic import BaseModel
+
+
+class TokenUsage(BaseModel):
+    input_tokens: int = 0
+    output_tokens: int = 0
+    tool_use_tokens: int = 0
+    thoughts_tokens: int = 0
+    total_tokens: int = 0
+    calculated_total_tokens: int = 0
+
+    input_cost: float = 0
+    output_cost: float = 0
+    tool_use_cost: float = 0
+    thoughts_cost: float = 0
+    total_cost: float = 0
+
+    def __add__(self, other: "TokenUsage") -> "TokenUsage":
+        return TokenUsage(
+            input_tokens=self.input_tokens + other.input_tokens,
+            output_tokens=self.output_tokens + other.output_tokens,
+            total_tokens=self.total_tokens + other.total_tokens,
+            tool_use_tokens=self.tool_use_tokens + other.tool_use_tokens,
+            thoughts_tokens=self.thoughts_tokens + other.thoughts_tokens,
+            calculated_total_tokens=self.calculated_total_tokens
+            + other.calculated_total_tokens,
+            input_cost=self.input_cost + other.input_cost,
+            output_cost=self.output_cost + other.output_cost,
+            tool_use_cost=self.tool_use_cost + other.tool_use_cost,
+            thoughts_cost=self.thoughts_cost + other.thoughts_cost,
+            total_cost=self.total_cost + other.total_cost,
+        )
+
+    def __sub__(self, other: "TokenUsage") -> "TokenUsage":
+        return TokenUsage(
+            input_tokens=self.input_tokens - other.input_tokens,
+            output_tokens=self.output_tokens - other.output_tokens,
+            total_tokens=self.total_tokens - other.total_tokens,
+            tool_use_tokens=self.tool_use_tokens - other.tool_use_tokens,
+            thoughts_tokens=self.thoughts_tokens - other.thoughts_tokens,
+            calculated_total_tokens=self.calculated_total_tokens
+            - other.calculated_total_tokens,
+            input_cost=self.input_cost - other.input_cost,
+            output_cost=self.output_cost - other.output_cost,
+            tool_use_cost=self.tool_use_cost - other.tool_use_cost,
+            thoughts_cost=self.thoughts_cost - other.thoughts_cost,
+            total_cost=self.total_cost - other.total_cost,
+        )

optexity/utils/settings.py

@@ -0,0 +1,54 @@
+import logging
+import os
+from typing import Literal
+
+from pydantic import model_validator
+from pydantic_settings import BaseSettings
+
+logger = logging.getLogger(__name__)
+
+env_path = os.getenv("ENV_PATH")
+if not env_path:
+    logger.warning("ENV_PATH is not set, using default values")
+
+
+class Settings(BaseSettings):
+    SERVER_URL: str = "https://api.optexity.com"
+    HEALTH_ENDPOINT: str = "api/v1/health"
+    INFERENCE_ENDPOINT: str = "api/v1/inference"
+    ADD_EXAMPLE_ENDPOINT: str = "api/v1/add_example"
+    UPDATE_EXAMPLE_ENDPOINT: str = "api/v1/update_example"
+    START_TASK_ENDPOINT: str = "api/v1/start_task"
+    COMPLETE_TASK_ENDPOINT: str = "api/v1/complete_task"
+    SAVE_OUTPUT_DATA_ENDPOINT: str = "api/v1/save_output_data"
+    SAVE_DOWNLOADS_ENDPOINT: str = "api/v1/save_downloads"
+    SAVE_TRAJECTORY_ENDPOINT: str = "api/v1/save_trajectory"
+    INITIATE_CALLBACK_ENDPOINT: str = "api/v1/initiate_callback"
+    GET_CALLBACK_DATA_ENDPOINT: str = "api/v1/get_callback_data"
+    FETCH_EMAIL_MESSAGES_ENDPOINT: str = "api/v1/fetch_email_messages"
+    FETCH_SLACK_MESSAGES_ENDPOINT: str = "api/v1/fetch_slack_messages"
+
+    API_KEY: str
+
+    CHILD_PORT_OFFSET: int = 9000
+    DEPLOYMENT: Literal["dev", "prod"]
+    LOCAL_CALLBACK_URL: str | None = None
+
+    PROXY_URL: str | None = None
+    PROXY_USERNAME: str | None = None
+    PROXY_PASSWORD: str | None = None
+    PROXY_COUNTRY: str | None = None
+    PROXY_PROVIDER: Literal["oxylabs", "brightdata", "other"] | None = None
+
+    @model_validator(mode="after")
+    def validate_local_callback_url(self):
+        if self.DEPLOYMENT == "prod" and self.LOCAL_CALLBACK_URL is not None:
+            raise ValueError("LOCAL_CALLBACK_URL is not allowed in prod mode")
+        return self
+
+    class Config:
+        env_file = env_path if env_path else None
+        extra = "allow"
+
+
+settings = Settings()

optexity/utils/utils.py

@@ -0,0 +1,76 @@
+import base64
+import logging
+import os
+from pathlib import Path
+from typing import List, Optional
+
+import aiofiles
+import pyotp
+from async_lru import alru_cache
+from onepassword import Client as OnePasswordClient
+from pydantic import create_model
+
+logger = logging.getLogger(__name__)
+
+_onepassword_client = None
+
+
+async def get_onepassword_client():
+    global _onepassword_client
+    if _onepassword_client is None:
+        _onepassword_client = await OnePasswordClient.authenticate(
+            auth=os.getenv("OP_SERVICE_ACCOUNT_TOKEN"),
+            integration_name="Optexity 1Password Integration",
+            integration_version="v1.0.0",
+        )
+    return _onepassword_client
+
+
+def build_model(schema: dict, model_name="AutoModel"):
+    fields = {}
+    for key, value in schema.items():
+        if isinstance(value, str):  # primitive type
+            py_type = eval(value)  # e.g., "str" -> str
+            fields[key] = (Optional[py_type], None)
+        elif isinstance(value, dict):  # nested object
+            sub_model = build_model(value, model_name=f"{model_name}_{key}")
+            fields[key] = (Optional[sub_model], None)
+        elif isinstance(value, list):  # list of objects or primitives
+            if len(value) > 0 and isinstance(value[0], dict):
+                sub_model = build_model(value[0], model_name=f"{model_name}_{key}")
+                fields[key] = (Optional[List[sub_model]], None)
+            else:  # list of primitives
+                py_type = eval(value[0])
+                fields[key] = (Optional[List[py_type]], None)
+    return create_model(model_name, **fields)
+
+
+def save_screenshot(screenshot: str, path: str):
+    with open(path, "wb") as f:
+        f.write(base64.b64decode(screenshot))
+
+
+async def save_and_clear_downloaded_files(content: bytes | str, filename: Path):
+    if isinstance(content, bytes):
+        async with aiofiles.open(filename, "wb") as f:
+            await f.write(content)
+    elif isinstance(content, str):
+        async with aiofiles.open(filename, "w") as f:
+            await f.write(content)
+    else:
+        logger.error(f"Unsupported content type: {type(content)}")
+
+
+def get_totp_code(totp_secret: str, digits: int = 6):
+    totp = pyotp.TOTP(totp_secret, digits=digits)
+    return totp.now()
+
+
+@alru_cache(maxsize=1000)
+async def get_onepassword_value(vault_name: str, item_name: str, field_name: str):
+    client = await get_onepassword_client()
+    str_value = await client.secrets.resolve(
+        f"op://{vault_name}/{item_name}/{field_name}"
+    )
+
+    return str_value

{optexity-0.1.2.dist-info → optexity-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optexity
-Version: 0.1.2
+Version: 0.1.4
 Summary: Optexity is a platform for building and running browser and computer agents.
 Author-email: Optexity <support@optexity.com>
 Requires-Python: >=3.11
@@ -50,30 +50,19 @@ Once logged in, navigate to the **API Keys** section in your dashboard and creat
 
 Install the **Optexity Recorder** extension from the [Chrome Web Store](https://chromewebstore.google.com/detail/optexity-recorder/pbaganbicadeoacahamnbgohafchgakp). This extension captures your browser interactions and converts them into automation workflows.
 
-## Installation
-
 ### Prerequisites
 
 - Python 3.11+
-- Node.js 18+ (included with Conda option)
 - Git
 
-### Step 1: Clone the Repository
-
-```bash
-git clone git@github.com:Optexity/optexity.git
-cd optexity
-./update_submodule.sh
-```
-
-### Step 2: Create and Activate a Python Environment
+## Create and Activate a Python Environment (Optional)
 
 Choose **one** of the options below.
 
 #### Option A – Conda (includes Python 3.11 and Node.js)
 
 ```bash
-conda create -n optexity python=3.11 nodejs
+conda create -n optexity python=3.11
 conda activate optexity
 ```
 
@@ -86,32 +75,29 @@ python3 -m venv .venv
 source .venv/bin/activate
 ```
 
-> If you pick `venv`, ensure Node.js 18+ is already available on your machine before continuing.
+## Installation
 
-### Step 3: Install Dependencies
+### Quick Installation (from PyPI)
 
-Run everything from the repository root:
+Install Optexity directly from PyPI:
 
 ```bash
-pip install -e "external/browser-use"
-pip install -e .
-playwright install --with-deps chromium chrome
-patchright install chromium chrome
-pre-commit install --install-hooks
-pre-commit install --hook-type pre-push
+pip install optexity
 ```
+**OR**
 
-### Step 4: Configure Your Environment
+### Installation from Source
 
-Optexity reads configuration from a standard `.env` file via the `ENV_PATH` environment variable.
+If you want to clone and edit from source:
 
-Create a `.env` file in the repo root:
 
 ```bash
-touch .env
+git clone git@github.com:Optexity/optexity.git
+cd optexity
+pip install -e .
 ```
 
-Add the required values:
+## Set required environment variables:
 
 ```bash
 API_KEY=YOUR_OPTEXITY_API_KEY           # API key used for authenticated requests
@@ -121,14 +107,14 @@ DEPLOYMENT=dev                          # or "prod" in production
 
 You can get your free Google Gemini API key from the [Google AI Studio Console](https://aistudio.google.com).
 
-Then export `ENV_PATH` when running processes that rely on these settings:
+## Install required browsers:
+
+Install playwright and patchright browsers:
 
 ```bash
-export ENV_PATH=.env
+optexity install-browsers
 ```
 
-> If `ENV_PATH` is not set, the inference server will try to start with defaults and log a warning. For normal usage you should always point `ENV_PATH` at a real `.env` file.
-
 ## Recording Your First Automation
 
 The fastest way to create an automation is by recording your actions directly in the browser.
@@ -156,12 +142,10 @@ The fastest way to create an automation is by recording your actions directly in
 
 ### Start the Inference Server
 
-The primary way to run browser automations locally is via the inference child process server.
-
-From the repository root:
+The primary way to run browser automations locally is via the inference server.
 
 ```bash
-ENV_PATH=.env python optexity/inference/child_process.py --port 9000 --child_process_id 0
+optexity inference --port 9000 --child_process_id 0
 ```
 
 Key parameters:

optexity-0.1.4.dist-info/RECORD

@@ -0,0 +1,80 @@
+optexity/__init__.py,sha256=dqh4tGEzruZnkvRLjPYKyc2-FVlXLx1Dj-JNy5fy7U8,459
+optexity/cli.py,sha256=2g_p2Qh7jzFFG5T0aTDiZ7Celh-KycEMJ873whiXFXE,2237
+optexity/exceptions.py,sha256=j4QxbcnAl5RmEJPJ0MWZ0iM38HvW-r8xmxtDxZ1ceSY,269
+optexity/onepassword_integration.py,sha256=_1sQ8sRGVdDnA7384FXiXYRVntPB-ZQAu8W7ICX7_VQ,1047
+optexity/test.py,sha256=pMSZwwA8tj6jAfFUJ3OUHGnTPriqkv4eDGGHqdAdrsA,2797
+optexity/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+optexity/examples/add_example.py,sha256=jVPd2pQ9lnmdwsVsld52CkRafYcF60SrQyDU3QFKTwY,2474
+optexity/examples/download_pdf_url.py,sha256=mB1Kp0UC4AuHeIiyxMt5tlNK5urNPUosHjmUvV67qdM,829
+optexity/examples/extract_price_stockanalysis.py,sha256=oUMAXW0TKFjJO6KCDIsThaMwNNC_Zx5_ZfkuYTo9xmE,1520
+optexity/examples/file_upload.py,sha256=Ep9wxjZFjlcWVufkhLt_RufZMbC8BJ8amASFO7uKGCk,2030
+optexity/examples/i94.py,sha256=QB-Vo6jB03wOovsNh6_TsdxvdJf3MbnxVeUlEoVtUhA,4534
+optexity/examples/i94_travel_history.py,sha256=PbU-xg3xVoEgRPaZQfC5JPNcHA6ClTu8X7650TK1_dc,4573
+optexity/examples/peachstate_medicaid.py,sha256=0PQN3SI5NGw0m95ODm-bHYgF0xwpA83_9xflnN8P4mM,8290
+optexity/examples/supabase_login.py,sha256=_j5VZi0HkqpWl0xguMoHc3gfkf3FiJWnQPs8D_QARN4,2349
+optexity/inference/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+optexity/inference/child_process.py,sha256=0-HoM9yUtYf7BzfCeKS_uUO4NfrdAESryuHaKYRwEoY,8098
+optexity/inference/run_local.py,sha256=P-ghDcNhHESuG7Q6Qp6xdl6r0g2lAyDkIhKsyaLBcPs,6743
+optexity/inference/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+optexity/inference/agents/error_handler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+optexity/inference/agents/error_handler/error_handler.py,sha256=95T19gFgdvOcD1lVbEDmuB9-D5LB_08xAjSc2ezyaCs,1111
+optexity/inference/agents/error_handler/prompt.py,sha256=911fxUvQzG2OhjstGSB0ioDOeZopmuHCfPVOY4cZSbM,4333
+optexity/inference/agents/index_prediction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+optexity/inference/agents/index_prediction/action_prediction_locator_axtree.py,sha256=KJdBss76h92iYpiwdwBUhsfhtGeVnhsGMokdJvGsjj4,1280
+optexity/inference/agents/index_prediction/prompt.py,sha256=51nMQExOmVEVoMWr2hkYGdR9_yDMXt0m1LxhILILT2E,1005
+optexity/inference/agents/select_value_prediction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+optexity/inference/agents/select_value_prediction/prompt.py,sha256=r59j6P4TN-NtGjpmtTsjLxH_nsoLeukMNDE0_cVqj_4,1351
+optexity/inference/agents/select_value_prediction/select_value_prediction.py,sha256=QlBdZRW_QJ1xS8b8CY25UlPHcS1obuwKxjVoZl9b30k,1167
+optexity/inference/agents/two_fa_extraction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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/run_assertion.py,sha256=8ydAkSA2E0VajwKZlY2z4Xxxyzo49UsFIZ7ej_l0Cy8,2224
+optexity/inference/core/run_automation.py,sha256=aXsEj3M7BN_VlpDZgZdScsQHB7jfukCAKGvyBSjUMjA,16708
+optexity/inference/core/run_extraction.py,sha256=TaUfFCcKxuMEJELDhcYMjpbyxgRrdVMHNIX6pjo7l5U,7576
+optexity/inference/core/run_interaction.py,sha256=Rs6Sa4cqTpR1jNNPh2IRYfj4sKcFgtWbjTaQN-wRICs,9248
+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/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=IhdYjj-oNGoJInN9XK6ppqW6JQgCNm7t2COymv5T9O8,2249
+optexity/inference/core/interaction/handle_command.py,sha256=a0Eqs5eDJ4bPttqMh4r_IAYJzpXcH9bvUS_9CG8MySA,8350
+optexity/inference/core/interaction/handle_input.py,sha256=UGALiQLUgjgg5Z-vj4lEoEs4_GXCirUBgONUulKs0oU,2256
+optexity/inference/core/interaction/handle_keypress.py,sha256=Ig-U7qoMQ1GIaxeS2TnSTe4N3Jj64WcVc1rwl7Z-0So,466
+optexity/inference/core/interaction/handle_select.py,sha256=1nTm-hyaG4xDnItdulW1--b0zj20FdJq7qks5X-aNKU,3236
+optexity/inference/core/interaction/handle_select_utils.py,sha256=gJnIvBNPFwIkFjYiaVSB-91k95leahrSnlq8fgDcWbQ,4114
+optexity/inference/core/interaction/handle_upload.py,sha256=cIe9lcgA8_jT1KMGcImfqq_PEEVY-Fy5YZjrX2GA8As,1818
+optexity/inference/core/interaction/utils.py,sha256=iWKfn7cF-8duQoMvGfmGV05oOuQEyKPgOdMJe_Hk4KM,2745
+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_extension.py,sha256=Ur5_8DrHcgRkD9uulDsVaaj01z1WcsvqHxHok4p4RoM,589
+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=by9pcgCpG1yDEowBQGeVa30vQ3hO-GCtTiJdcSf4RKY,16121
+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/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/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/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.4.dist-info/licenses/LICENSE,sha256=WpSBqSAcwd68PmS3zRsfACJOz-u-UfTzftsEnzp4ZCY,1065
+optexity-0.1.4.dist-info/METADATA,sha256=F4VEHUDrBUHucmeu--S6SsdsiNR93O75dBd4xp6VQyU,9878
+optexity-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+optexity-0.1.4.dist-info/entry_points.txt,sha256=hcn77ooRr6a_N8fo0vij3Fpo6waqc9ijpaScQ7Kj35k,47
+optexity-0.1.4.dist-info/top_level.txt,sha256=OZEtBX8IabC8EnBrNW98z7NzdGQsjFhHleSthhjjEMM,9
+optexity-0.1.4.dist-info/RECORD,,

optexity-0.1.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-optexity/__init__.py,sha256=dqh4tGEzruZnkvRLjPYKyc2-FVlXLx1Dj-JNy5fy7U8,459
-optexity/cli.py,sha256=bpHwMWGGJVS3TG2uUl2nSJkf916D-kCw_mxzAe_-XeI,2238
-optexity/exceptions.py,sha256=j4QxbcnAl5RmEJPJ0MWZ0iM38HvW-r8xmxtDxZ1ceSY,269
-optexity/onepassword_integration.py,sha256=_1sQ8sRGVdDnA7384FXiXYRVntPB-ZQAu8W7ICX7_VQ,1047
-optexity/test.py,sha256=pMSZwwA8tj6jAfFUJ3OUHGnTPriqkv4eDGGHqdAdrsA,2797
-optexity-0.1.2.dist-info/licenses/LICENSE,sha256=WpSBqSAcwd68PmS3zRsfACJOz-u-UfTzftsEnzp4ZCY,1065
-optexity-0.1.2.dist-info/METADATA,sha256=hVH-kaFUYJHPOIF5-PVJGA3x8YMUNCjGYpW3J23dXmk,10613
-optexity-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-optexity-0.1.2.dist-info/entry_points.txt,sha256=hcn77ooRr6a_N8fo0vij3Fpo6waqc9ijpaScQ7Kj35k,47
-optexity-0.1.2.dist-info/top_level.txt,sha256=OZEtBX8IabC8EnBrNW98z7NzdGQsjFhHleSthhjjEMM,9
-optexity-0.1.2.dist-info/RECORD,,