fleet-python 0.2.17__py3-none-any.whl → 0.2.19__py3-none-any.whl

fleet/__init__.py

@@ -37,9 +37,6 @@ from .verifiers import (
     TASK_SUCCESSFUL_SCORE,
 )
 
-# Import Playwright wrapper
-from .playwright import FleetPlaywrightWrapper
-
 # Import async verifiers (default verifier is async for modern usage)
 from ._async.verifiers import (
     verifier,
@@ -75,8 +72,6 @@ __all__ = [
     "FleetAPIError", 
     "FleetTimeoutError",
     "FleetConfigurationError",
-    # Playwright wrapper
-    "FleetPlaywrightWrapper",
     # Verifiers (async is default)
     "verifier",
     "verifier_sync", 

fleet/client.py

@@ -537,12 +537,6 @@ class Fleet:
         browser = new_env.browser()
         browser.start(width=snapshot.viewport_size[0], height=snapshot.viewport_size[1])
 
-        from fleet.playwright import FleetPlaywrightWrapper
-
-        playwright_wrapper = FleetPlaywrightWrapper(
-            cdp_url=browser.cdp_url(), instance_client=new_env.instance
-        )
-
         # Replay tool logs in order
         validation_errors = []
         last_timestamp = None
@@ -559,7 +553,7 @@ class Fleet:
 
                 # Replay the tool action
                 _replay_tool_action(
-                    playwright_wrapper,
+                    None,
                     tool_log,
                     new_env.instance._client,
                     replay_session_id,
@@ -588,7 +582,7 @@ class Fleet:
 
         if validate:
             validation = _validate_resumed_state(
-                new_env, snapshot, playwright_wrapper, validation_errors
+                new_env, snapshot, None, validation_errors
             )
 
         return new_env, validation
@@ -664,7 +658,7 @@ def _execute_verifier_remote(
 
 
 def _replay_tool_action(
-    playwright_wrapper: "FleetPlaywrightWrapper",
+    playwright_wrapper,
     tool_log: ToolLogEntry,
     client: "SyncWrapper",
     session_id: str,
@@ -760,7 +754,7 @@ def _replay_tool_action(
 def _validate_resumed_state(
     new_env: Environment,
     snapshot: EnvironmentSnapshot,
-    playwright_wrapper: "FleetPlaywrightWrapper",
+    playwright_wrapper,
     existing_errors: List[str],
 ) -> SnapshotValidation:
     """Validate that the resumed state matches the snapshot."""

fleet/resources/mcp.py

@@ -1,5 +1,4 @@
 from typing import Dict
-import aiohttp
 import json
 
 
@@ -24,6 +23,7 @@ class MCPResource:
         }
 
     async def list_tools(self):
+        import aiohttp
         """
         Make an async request to list available tools from the MCP endpoint.
         

fleet/resources/sqlite.py

@@ -18,7 +18,7 @@ from ..verifiers.db import IgnoreConfig, _get_row_identifier, _format_row_for_er
 
 
 class SyncDatabaseSnapshot:
-    """Async database snapshot that fetches data through API and stores locally for diffing."""
+    """Lazy database snapshot that fetches data on-demand through API."""
     
     def __init__(self, resource: "SQLiteResource", name: str | None = None):
         self.resource = resource
@@ -26,11 +26,12 @@ class SyncDatabaseSnapshot:
         self.created_at = datetime.utcnow()
         self._data: dict[str, list[dict[str, Any]]] = {}
         self._schemas: dict[str, list[str]] = {}
-        self._fetched = False
+        self._table_names: list[str] | None = None
+        self._fetched_tables: set[str] = set()
         
-    def _ensure_fetched(self):
-        """Fetch all data from remote database if not already fetched."""
-        if self._fetched:
+    def _ensure_tables_list(self):
+        """Fetch just the list of table names if not already fetched."""
+        if self._table_names is not None:
             return
             
         # Get all tables
@@ -39,34 +40,37 @@ class SyncDatabaseSnapshot:
         )
         
         if not tables_response.rows:
-            self._fetched = True
+            self._table_names = []
             return
             
-        table_names = [row[0] for row in tables_response.rows]
-        
-        # Fetch data from each table
-        for table in table_names:
-            # Get table schema
-            schema_response = self.resource.query(f"PRAGMA table_info({table})")
-            if schema_response.rows:
-                self._schemas[table] = [row[1] for row in schema_response.rows]  # Column names
-            
-            # Get all data
-            data_response = self.resource.query(f"SELECT * FROM {table}")
-            if data_response.rows and data_response.columns:
-                self._data[table] = [
-                    dict(zip(data_response.columns, row))
-                    for row in data_response.rows
-                ]
-            else:
-                self._data[table] = []
-                
-        self._fetched = True
+        self._table_names = [row[0] for row in tables_response.rows]
+        
+    def _ensure_table_data(self, table: str):
+        """Fetch data for a specific table on demand."""
+        if table in self._fetched_tables:
+            return
+            
+        # Get table schema
+        schema_response = self.resource.query(f"PRAGMA table_info({table})")
+        if schema_response.rows:
+            self._schemas[table] = [row[1] for row in schema_response.rows]  # Column names
+        
+        # Get all data for this table
+        data_response = self.resource.query(f"SELECT * FROM {table}")
+        if data_response.rows and data_response.columns:
+            self._data[table] = [
+                dict(zip(data_response.columns, row))
+                for row in data_response.rows
+            ]
+        else:
+            self._data[table] = []
+            
+        self._fetched_tables.add(table)
         
     def tables(self) -> list[str]:
         """Get list of all tables in the snapshot."""
-        self._ensure_fetched()
-        return list(self._data.keys())
+        self._ensure_tables_list()
+        return list(self._table_names) if self._table_names else []
         
     def table(self, table_name: str) -> "SyncSnapshotQueryBuilder":
         """Create a query builder for snapshot data."""
@@ -78,13 +82,12 @@ class SyncDatabaseSnapshot:
         ignore_config: IgnoreConfig | None = None,
     ) -> "SyncSnapshotDiff":
         """Compare this snapshot with another."""
-        self._ensure_fetched()
-        other._ensure_fetched()
+        # No need to fetch all data upfront - diff will fetch on demand
         return SyncSnapshotDiff(self, other, ignore_config)
 
 
 class SyncSnapshotQueryBuilder:
-    """Query builder that works on local snapshot data."""
+    """Query builder that works on snapshot data - can use targeted queries when possible."""
     
     def __init__(self, snapshot: SyncDatabaseSnapshot, table: str):
         self._snapshot = snapshot
@@ -94,10 +97,63 @@ class SyncSnapshotQueryBuilder:
         self._limit: int | None = None
         self._order_by: str | None = None
         self._order_desc: bool = False
+        self._use_targeted_query = True  # Try to use targeted queries when possible
+        
+    def _can_use_targeted_query(self) -> bool:
+        """Check if we can use a targeted query instead of loading all data."""
+        # We can use targeted query if:
+        # 1. We have simple equality conditions
+        # 2. No complex operations like joins
+        # 3. The query is selective (has conditions)
+        if not self._conditions:
+            return False
+        for col, op, val in self._conditions:
+            if op not in ["=", "IS", "IS NOT"]:
+                return False
+        return True
+        
+    def _execute_targeted_query(self) -> list[dict[str, Any]]:
+        """Execute a targeted query directly instead of loading all data."""
+        # Build WHERE clause
+        where_parts = []
+        for col, op, val in self._conditions:
+            if op == "=" and val is None:
+                where_parts.append(f"{col} IS NULL")
+            elif op == "IS":
+                where_parts.append(f"{col} IS NULL")
+            elif op == "IS NOT":
+                where_parts.append(f"{col} IS NOT NULL")
+            elif op == "=":
+                if isinstance(val, str):
+                    escaped_val = val.replace("'", "''")
+                    where_parts.append(f"{col} = '{escaped_val}'")
+                else:
+                    where_parts.append(f"{col} = '{val}'")
+        
+        where_clause = " AND ".join(where_parts)
+        
+        # Build full query
+        cols = ", ".join(self._select_cols)
+        query = f"SELECT {cols} FROM {self._table} WHERE {where_clause}"
+        
+        if self._order_by:
+            query += f" ORDER BY {self._order_by}"
+        if self._limit is not None:
+            query += f" LIMIT {self._limit}"
+            
+        # Execute query
+        response = self._snapshot.resource.query(query)
+        if response.rows and response.columns:
+            return [dict(zip(response.columns, row)) for row in response.rows]
+        return []
         
     def _get_data(self) -> list[dict[str, Any]]:
-        """Get table data from snapshot."""
-        self._snapshot._ensure_fetched()
+        """Get table data - use targeted query if possible, otherwise load all data."""
+        if self._use_targeted_query and self._can_use_targeted_query():
+            return self._execute_targeted_query()
+        
+        # Fall back to loading all data
+        self._snapshot._ensure_table_data(self._table)
         return self._snapshot._data.get(self._table, [])
         
     def eq(self, column: str, value: Any) -> "SyncSnapshotQueryBuilder":
@@ -121,6 +177,11 @@ class SyncSnapshotQueryBuilder:
         return rows[0] if rows else None
         
     def all(self) -> list[dict[str, Any]]:
+        # If we can use targeted query, _get_data already applies filters
+        if self._use_targeted_query and self._can_use_targeted_query():
+            return self._get_data()
+            
+        # Otherwise, get all data and apply filters manually
         data = self._get_data()
         
         # Apply filters
@@ -188,6 +249,7 @@ class SyncSnapshotDiff:
         self.after = after
         self.ignore_config = ignore_config or IgnoreConfig()
         self._cached: dict[str, Any] | None = None
+        self._targeted_mode = False  # Flag to use targeted queries
         
     def _get_primary_key_columns(self, table: str) -> list[str]:
         """Get primary key columns for a table."""
@@ -228,6 +290,10 @@ class SyncSnapshotDiff:
             # Get primary key columns
             pk_columns = self._get_primary_key_columns(tbl)
             
+            # Ensure data is fetched for this table
+            self.before._ensure_table_data(tbl)
+            self.after._ensure_table_data(tbl)
+            
             # Get data from both snapshots
             before_data = self.before._data.get(tbl, [])
             after_data = self.after._data.get(tbl, [])
@@ -303,10 +369,245 @@ class SyncSnapshotDiff:
         self._cached = diff
         return diff
         
-    def expect_only(self, allowed_changes: list[dict[str, Any]]):
-        """Ensure only specified changes occurred."""
+    def _can_use_targeted_queries(self, allowed_changes: list[dict[str, Any]]) -> bool:
+        """Check if we can use targeted queries for optimization."""
+        # We can use targeted queries if all allowed changes specify table and pk
+        for change in allowed_changes:
+            if "table" not in change or "pk" not in change:
+                return False
+        return True
+        
+    def _expect_only_targeted(self, allowed_changes: list[dict[str, Any]]):
+        """Optimized version that only queries specific rows mentioned in allowed_changes."""
+        # Group allowed changes by table
+        changes_by_table: dict[str, list[dict[str, Any]]] = {}
+        for change in allowed_changes:
+            table = change["table"]
+            if table not in changes_by_table:
+                changes_by_table[table] = []
+            changes_by_table[table].append(change)
+        
+        # For each table with allowed changes, query only those specific rows
+        for table, table_changes in changes_by_table.items():
+            if self.ignore_config.should_ignore_table(table):
+                continue
+                
+            # Get primary key columns
+            pk_columns = self._get_primary_key_columns(table)
+            
+            # Extract unique PKs to check
+            pks_to_check = {change["pk"] for change in table_changes}
+            
+            # Query only these specific rows from both snapshots
+            for pk in pks_to_check:
+                # Build WHERE clause for this PK
+                where_sql = self._build_pk_where_clause(pk_columns, pk)
+                
+                # Query before snapshot
+                before_query = f"SELECT * FROM {table} WHERE {where_sql}"
+                before_response = self.before.resource.query(before_query)
+                before_row = dict(zip(before_response.columns, before_response.rows[0])) if before_response.rows else None
+                
+                # Query after snapshot  
+                after_response = self.after.resource.query(before_query)
+                after_row = dict(zip(after_response.columns, after_response.rows[0])) if after_response.rows else None
+                
+                # Check changes for this row
+                if before_row and after_row:
+                    # Modified row - check fields
+                    for field in set(before_row.keys()) | set(after_row.keys()):
+                        if self.ignore_config.should_ignore_field(table, field):
+                            continue
+                        before_val = before_row.get(field)
+                        after_val = after_row.get(field)
+                        if not _values_equivalent(before_val, after_val):
+                            # Check if this change is allowed
+                            if not self._is_field_change_allowed(table_changes, pk, field, after_val):
+                                raise AssertionError(
+                                    f"Unexpected change in table '{table}', "
+                                    f"row {pk}, field '{field}': "
+                                    f"{repr(before_val)} -> {repr(after_val)}"
+                                )
+                elif not before_row and after_row:
+                    # Added row
+                    if not self._is_row_change_allowed(table_changes, pk, "__added__"):
+                        raise AssertionError(f"Unexpected row added in table '{table}': {pk}")
+                elif before_row and not after_row:
+                    # Removed row
+                    if not self._is_row_change_allowed(table_changes, pk, "__removed__"):
+                        raise AssertionError(f"Unexpected row removed from table '{table}': {pk}")
+        
+        # Now check tables not mentioned in allowed_changes to ensure no changes
+        all_tables = set(self.before.tables()) | set(self.after.tables())
+        for table in all_tables:
+            if table in changes_by_table or self.ignore_config.should_ignore_table(table):
+                continue
+            
+            # For tables with no allowed changes, just check row counts
+            before_count_response = self.before.resource.query(f"SELECT COUNT(*) FROM {table}")
+            before_count = before_count_response.rows[0][0] if before_count_response.rows else 0
+            
+            after_count_response = self.after.resource.query(f"SELECT COUNT(*) FROM {table}")
+            after_count = after_count_response.rows[0][0] if after_count_response.rows else 0
+            
+            if before_count != after_count:
+                raise AssertionError(
+                    f"Unexpected change in table '{table}': "
+                    f"row count changed from {before_count} to {after_count}"
+                )
+        
+        return self
+        
+    def _build_pk_where_clause(self, pk_columns: list[str], pk_value: Any) -> str:
+        """Build WHERE clause for primary key lookup."""
+        # Escape single quotes in values to prevent SQL injection
+        def escape_value(val: Any) -> str:
+            if val is None:
+                return "NULL"
+            elif isinstance(val, str):
+                escaped = str(val).replace("'", "''")
+                return f"'{escaped}'"
+            else:
+                return f"'{val}'"
+                
+        if len(pk_columns) == 1:
+            return f"{pk_columns[0]} = {escape_value(pk_value)}"
+        else:
+            # Composite key
+            if isinstance(pk_value, tuple):
+                conditions = [f"{col} = {escape_value(val)}" for col, val in zip(pk_columns, pk_value)]
+                return " AND ".join(conditions)
+            else:
+                # Shouldn't happen if data is consistent
+                return f"{pk_columns[0]} = {escape_value(pk_value)}"
+                
+    def _is_field_change_allowed(self, table_changes: list[dict[str, Any]], pk: Any, field: str, after_val: Any) -> bool:
+        """Check if a specific field change is allowed."""
+        for change in table_changes:
+            if (str(change.get("pk")) == str(pk) and 
+                change.get("field") == field and
+                _values_equivalent(change.get("after"), after_val)):
+                return True
+        return False
+        
+    def _is_row_change_allowed(self, table_changes: list[dict[str, Any]], pk: Any, change_type: str) -> bool:
+        """Check if a row addition/deletion is allowed."""
+        for change in table_changes:
+            if str(change.get("pk")) == str(pk) and change.get("after") == change_type:
+                return True
+        return False
+        
+    def _expect_no_changes(self):
+        """Efficiently verify that no changes occurred between snapshots using row counts."""
+        try:
+            # Get all tables from both snapshots
+            before_tables = set(self.before.tables())
+            after_tables = set(self.after.tables())
+            
+            # Check for added/removed tables (excluding ignored ones)
+            added_tables = after_tables - before_tables
+            removed_tables = before_tables - after_tables
+            
+            for table in added_tables:
+                if not self.ignore_config.should_ignore_table(table):
+                    raise AssertionError(f"Unexpected table added: {table}")
+                    
+            for table in removed_tables:
+                if not self.ignore_config.should_ignore_table(table):
+                    raise AssertionError(f"Unexpected table removed: {table}")
+            
+            # For each table, compare row counts
+            all_tables = before_tables | after_tables
+            for table in all_tables:
+                if self.ignore_config.should_ignore_table(table):
+                    continue
+                    
+                # Get row counts from both snapshots
+                before_count = 0
+                after_count = 0
+                
+                if table in before_tables:
+                    before_count_response = self.before.resource.query(f"SELECT COUNT(*) FROM {table}")
+                    before_count = before_count_response.rows[0][0] if before_count_response.rows else 0
+                    
+                if table in after_tables:
+                    after_count_response = self.after.resource.query(f"SELECT COUNT(*) FROM {table}")
+                    after_count = after_count_response.rows[0][0] if after_count_response.rows else 0
+                
+                if before_count != after_count:
+                    raise AssertionError(
+                        f"Unexpected change in table '{table}': "
+                        f"row count changed from {before_count} to {after_count}"
+                    )
+                    
+                # If counts match but there could be modifications, we need to check further
+                # For now, we'll do a more detailed check only if counts are small
+                # to avoid performance issues
+                if before_count > 0 and before_count <= 1000:  # Threshold for detailed check
+                    # Do a quick hash check of the data
+                    self._verify_table_unchanged(table)
+                elif before_count > 1000:
+                    # For large tables, we could sample or use checksums
+                    # For now, we'll trust that count matching means no changes
+                    # This is a reasonable assumption for expect_only([])
+                    pass
+                    
+            return self
+            
+        except AssertionError:
+            # Re-raise assertion errors (these are expected failures)
+            raise
+        except Exception as e:
+            # If the optimized check fails for other reasons, fall back to full diff
+            print(f"Warning: Optimized no-changes check failed: {e}")
+            print("Falling back to full diff...")
+            return self._expect_only_fallback([])
+            
+    def _verify_table_unchanged(self, table: str):
+        """Verify that a table's data hasn't changed (for small tables)."""
+        # Get primary key columns
+        pk_columns = self._get_primary_key_columns(table)
+        
+        # Get sorted data from both snapshots
+        order_by = ", ".join(pk_columns) if pk_columns else "rowid"
+        
+        before_response = self.before.resource.query(f"SELECT * FROM {table} ORDER BY {order_by}")
+        after_response = self.after.resource.query(f"SELECT * FROM {table} ORDER BY {order_by}")
+        
+        # Quick check: if column counts differ, there's a schema change
+        if before_response.columns != after_response.columns:
+            raise AssertionError(f"Schema changed in table '{table}'")
+            
+        # Compare row by row
+        if len(before_response.rows) != len(after_response.rows):
+            raise AssertionError(
+                f"Row count mismatch in table '{table}': "
+                f"{len(before_response.rows)} vs {len(after_response.rows)}"
+            )
+            
+        for i, (before_row, after_row) in enumerate(zip(before_response.rows, after_response.rows)):
+            before_dict = dict(zip(before_response.columns, before_row))
+            after_dict = dict(zip(after_response.columns, after_row))
+            
+            # Compare fields, ignoring those in ignore config
+            for field in before_response.columns:
+                if self.ignore_config.should_ignore_field(table, field):
+                    continue
+                    
+                if not _values_equivalent(before_dict.get(field), after_dict.get(field)):
+                    pk_val = before_dict.get(pk_columns[0]) if pk_columns else i
+                    raise AssertionError(
+                        f"Unexpected change in table '{table}', row {pk_val}, "
+                        f"field '{field}': {repr(before_dict.get(field))} -> {repr(after_dict.get(field))}"
+                    )
+                    
+    def _expect_only_fallback(self, allowed_changes: list[dict[str, Any]]):
+        """Fallback to full diff collection when optimized methods fail."""
         diff = self._collect()
+        return self._validate_diff_against_allowed_changes(diff, allowed_changes)
         
+    def _validate_diff_against_allowed_changes(self, diff: dict[str, Any], allowed_changes: list[dict[str, Any]]):
+        """Validate a collected diff against allowed changes."""
         def _is_change_allowed(
             table: str, row_id: Any, field: str | None, after_value: Any
         ) -> bool:
@@ -419,6 +720,20 @@ class SyncSnapshotDiff:
             raise AssertionError("\n".join(error_lines))
             
         return self
+        
+    def expect_only(self, allowed_changes: list[dict[str, Any]]):
+        """Ensure only specified changes occurred."""
+        # Special case: empty allowed_changes means no changes should have occurred
+        if not allowed_changes:
+            return self._expect_no_changes()
+            
+        # For expect_only, we can optimize by only checking the specific rows mentioned
+        if self._can_use_targeted_queries(allowed_changes):
+            return self._expect_only_targeted(allowed_changes)
+        
+        # Fall back to full diff for complex cases
+        diff = self._collect()
+        return self._validate_diff_against_allowed_changes(diff, allowed_changes)
 
 
 class SyncQueryBuilder:
@@ -669,9 +984,8 @@ class SQLiteResource(Resource):
 
     def snapshot(self, name: str | None = None) -> SyncDatabaseSnapshot:
         """Create a snapshot of the current database state."""
-        snapshot = SyncDatabaseSnapshot(self, name)
-        snapshot._ensure_fetched()
-        return snapshot
+        # No longer fetch all data upfront - let it be lazy
+        return SyncDatabaseSnapshot(self, name)
 
     def diff(
         self,

fleet/verifiers/code.py

@@ -1 +1,2 @@
-TASK_SUCCESSFUL_SCORE = 1
+TASK_SUCCESSFUL_SCORE = 1
+TASK_FAILED_SCORE = 0

{fleet_python-0.2.17.dist-info → fleet_python-0.2.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.17
+Version: 0.2.19
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0

{fleet_python-0.2.17.dist-info → fleet_python-0.2.19.dist-info}/RECORD

@@ -15,20 +15,18 @@ examples/openai_example.py,sha256=I2vk_SJN9BkSRQCYRJfbtGJ-HJ2xzQj-lOjwqmLos5M,82
 examples/openai_simple_example.py,sha256=I42ytIwv0INgDO39pp1MOQSqsJz2YYH8GeNNBaUtq3A,1748
 examples/query_builder_example.py,sha256=Q3lUBETHpu1aS2FXAO79ADYqCxOjMMMZNgCcFVapiII,3918
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
-fleet/__init__.py,sha256=V2y7yMsloc56E4QdluakrVRiITQLmasxmAOBJ1oJ3cU,2365
+fleet/__init__.py,sha256=9EsG068VCTqCCyBA2jw8IMLw4_oFkWLhtY394CtjEgM,2234
 fleet/base.py,sha256=0yYuMN0lBkrfTTZBt5NQp5112xWgziuWEk4GuHJB1wE,9189
-fleet/client.py,sha256=O08gVtngI-Fgo6kyQ-PdoaV8L63b2oQY20Ot2ZzBmSk,28540
+fleet/client.py,sha256=HrHkxQMk9_2GsyG7_edauKets3xySglCUuXW3WtXmTE,28263
 fleet/config.py,sha256=zd19st83NJdW9DdOq7Irpc0x-iUnMad0JOtAr_nD5DM,273
 fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/models.py,sha256=YMHFAgBF4OqoAOv-arHze3bPDDZ5DAzb3CXhVLF6pPw,9019
-fleet/playwright.py,sha256=BmRvez5DUa0ttAQB084hPAyt9_8WxdzCGBGF-GZbTuQ,8593
 fleet/tasks.py,sha256=w-0vVGfEuCWRHMEJ73SN141J7Lz2pD_0v-nNG4TyJTU,1645
 fleet/types.py,sha256=eXeI8BFmiU5hln0PVvJbUZs7BSjl6wSqAtN9zaJT6yY,652
 fleet/_async/__init__.py,sha256=AJWCnuo7XKja4yBb8fK2wX7ntciLXQrpzdRHwjTRP6M,62
 fleet/_async/base.py,sha256=s0rYOtXsMJeitOvpa-Oh8ciLV226p_TIPp3fplzWvV4,9209
 fleet/_async/client.py,sha256=yyNawgGro2sfFh0ok7DtbjnyxaBGrHg9RtTFEISvwdE,10581
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
-fleet/_async/playwright.py,sha256=NXKcwJezl6jEV2CKBgeaB7zLshFWypgSA5GYXevDRX8,8908
 fleet/_async/tasks.py,sha256=w-0vVGfEuCWRHMEJ73SN141J7Lz2pD_0v-nNG4TyJTU,1645
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/_async/env/client.py,sha256=PQGKcvnVTr3o2KNsgQM7ZBqaCjimv-wEn-XiYGm44Ko,753
@@ -51,19 +49,19 @@ fleet/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
 fleet/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/resources/base.py,sha256=203gD54NP1IvjuSqFo-f7FvrkhtjChggtzrxJK7xf2E,667
 fleet/resources/browser.py,sha256=OEqfNYPAptANza0T8K7UEn6nI7JnzlCICFMW8r2r83Q,1367
-fleet/resources/mcp.py,sha256=55LBwhNDqSeFVCD0O3OP9m2DdJE-KEYRQiCnVyze8DM,1864
-fleet/resources/sqlite.py,sha256=U0KneMzFKFrcuXcGrl4gkFPNoWST7_gWINphcA_UPJA,26251
+fleet/resources/mcp.py,sha256=lDMyY4pMC3Khwp2Wycc6Ds6KeLAUOgHkDnmztuAnXm8,1872
+fleet/resources/sqlite.py,sha256=aYR6OOrnUHwcUcbkXPLk4biNZI4VXGtPpN3F9n6t3-4,42132
 fleet/verifiers/__init__.py,sha256=-dm2x0wC8UbfGcMCbPtjb0-LospGUhD-S3Pm4oha6BY,445
 fleet/verifiers/bundler.py,sha256=A4yR3wBOcVZYFAv87CD58QlJn6L4QXeilrasnVm8n74,26185
-fleet/verifiers/code.py,sha256=NJ4OLZnpqLkI1lXY7-5m2GuZklLxMzHUCnRMVyN2_OI,25
+fleet/verifiers/code.py,sha256=EOi6ES8Zdzlm9iybRFaJmz9t2W4Ulo2wrCdbEBqxzbc,47
 fleet/verifiers/db.py,sha256=tssmvJjDHuBIy8qlL_P5-UdmEFUw2DZcqLsWZ8ot3Xw,27766
 fleet/verifiers/decorator.py,sha256=Q-KHhicnIYFwX7FX_VZguzNfu8ZslqNUeWxcS2CwNVY,3386
 fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
 fleet/verifiers/verifier.py,sha256=C5L24M7VBHWKaWlryC1EdW1g7keZBGzVSjgXC_SlpXA,12205
-fleet_python-0.2.17.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_python-0.2.19.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 scripts/fix_sync_imports.py,sha256=BIQfnaOoQ7bwR1c-pDqH9ifN47W1bwL7OafWVXZNkuA,4368
 scripts/unasync.py,sha256=--Fmaae47o-dZ1HYgX1c3Nvi-rMjcFymTRlJcWWnmpw,725
-fleet_python-0.2.17.dist-info/METADATA,sha256=j4d0xitYxfrKzk_5a97Phx5hC4ZNKXL8bQHlAe5izFA,3297
-fleet_python-0.2.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.17.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.17.dist-info/RECORD,,
+fleet_python-0.2.19.dist-info/METADATA,sha256=pzkr1yf1dDYvvaEvnwuit1M8goW9Xp3ah50dPyxmHew,3297
+fleet_python-0.2.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.19.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.19.dist-info/RECORD,,

fleet/_async/playwright.py

@@ -1,291 +0,0 @@
-import base64
-from typing import List, Dict, Any
-from playwright.async_api import async_playwright, Browser, Page
-from .client import AsyncEnv
-
-
-# Key mapping for computer use actions
-CUA_KEY_TO_PLAYWRIGHT_KEY = {
-    "/": "Divide",
-    "\\": "Backslash",
-    "alt": "Alt",
-    "arrowdown": "ArrowDown",
-    "arrowleft": "ArrowLeft",
-    "arrowright": "ArrowRight",
-    "arrowup": "ArrowUp",
-    "backspace": "Backspace",
-    "capslock": "CapsLock",
-    "cmd": "Meta",
-    "ctrl": "Control",
-    "delete": "Delete",
-    "end": "End",
-    "enter": "Enter",
-    "esc": "Escape",
-    "home": "Home",
-    "insert": "Insert",
-    "option": "Alt",
-    "pagedown": "PageDown",
-    "pageup": "PageUp",
-    "shift": "Shift",
-    "space": " ",
-    "super": "Meta",
-    "tab": "Tab",
-    "win": "Meta",
-}
-
-
-class AsyncFleetPlaywrightWrapper:
-    """
-    A wrapper that adds Playwright browser automation to Fleet environment instances.
-
-    This class handles:
-    - Browser connection via CDP
-    - Computer actions (click, scroll, type, etc.)
-    - Screenshot capture
-    - Integration with OpenAI computer use API
-
-    Usage:
-        instance = await fleet.env.make(env_key="hubspot", version="v1.2.7")
-        browser = AsyncFleetPlaywrightWrapper(instance)
-        await browser.start()
-
-        # Use browser methods
-        screenshot = await browser.screenshot()
-        tools = [browser.openai_cua_tool]
-
-        # Clean up when done
-        await browser.close()
-    """
-
-    def get_environment(self):
-        return "browser"
-
-    def get_dimensions(self):
-        return (1920, 1080)
-
-    def __init__(
-        self,
-        env: AsyncEnv,
-        display_width: int = 1920,
-        display_height: int = 1080,
-    ):
-        """
-        Initialize the Fleet Playwright wrapper.
-
-        Args:
-            env: Fleet environment instance
-            display_width: Browser viewport width
-            display_height: Browser viewport height
-        """
-        self.env = env
-        self.display_width = display_width
-        self.display_height = display_height
-
-        self._playwright = None
-        self._browser: Browser | None = None
-        self._page: Page | None = None
-        self._started = False
-
-    async def start(self):
-        """Start the browser and establish connection."""
-        if self._started:
-            return
-
-        # Start Playwright
-        self._playwright = await async_playwright().start()
-
-        # Start browser on the Fleet instance
-        print("Starting browser...")
-        await self.env.browser().start()
-        cdp = await self.env.browser().describe()
-
-        # Connect to browser
-        self._browser = await self._playwright.chromium.connect_over_cdp(
-            cdp.cdp_browser_url
-        )
-        self._page = self._browser.contexts[0].pages[0]
-        await self._page.set_viewport_size(
-            {"width": self.display_width, "height": self.display_height}
-        )
-
-        self._started = True
-        print(f"Track agent: {cdp.cdp_devtools_url}")
-
-    async def close(self):
-        """Close the browser connection."""
-        if self._playwright:
-            await self._playwright.stop()
-            self._playwright = None
-            self._browser = None
-            self._page = None
-            self._started = False
-
-    def _ensure_started(self):
-        """Ensure browser is started before operations."""
-        if not self._started:
-            raise RuntimeError("Browser not started. Call await browser.start() first.")
-
-    @property
-    def openai_cua_tool(self) -> Dict[str, Any]:
-        """
-        Tool definition for OpenAI computer use API.
-
-        Returns:
-            Tool definition dict for use with OpenAI responses API
-        """
-        return {
-            "type": "computer_use_preview",
-            "display_width": self.display_width,
-            "display_height": self.display_height,
-            "environment": "browser",
-        }
-
-    async def screenshot(self) -> str:
-        """
-        Take a screenshot and return base64 encoded string.
-
-        Returns:
-            Base64 encoded PNG screenshot
-        """
-        self._ensure_started()
-
-        png_bytes = await self._page.screenshot(full_page=False)
-        return base64.b64encode(png_bytes).decode("utf-8")
-
-    def get_current_url(self) -> str:
-        """Get the current page URL."""
-        self._ensure_started()
-        return self._page.url
-
-    async def execute_computer_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Execute a computer action and return the result for OpenAI API.
-
-        Args:
-            action: Computer action dict from OpenAI response
-
-        Returns:
-            Result dict for computer_call_output
-        """
-        self._ensure_started()
-
-        action_type = action["type"]
-        action_args = {k: v for k, v in action.items() if k != "type"}
-
-        print(f"Executing: {action_type}({action_args})")
-
-        # Execute the action
-        if hasattr(self, f"_{action_type}"):
-            method = getattr(self, f"_{action_type}")
-            await method(**action_args)
-        else:
-            raise ValueError(f"Unsupported action type: {action_type}")
-
-        # Take screenshot after action
-        screenshot_base64 = await self.screenshot()
-
-        return {
-            "type": "input_image",
-            "image_url": f"data:image/png;base64,{screenshot_base64}",
-            "current_url": self.get_current_url(),
-        }
-
-    # Computer action implementations
-    async def _click(self, x: int, y: int, button: str = "left") -> None:
-        """Click at coordinates."""
-        self._ensure_started()
-        await self._page.mouse.click(x, y, button=button)
-
-    async def _double_click(self, x: int, y: int) -> None:
-        """Double-click at coordinates."""
-        self._ensure_started()
-        await self._page.mouse.dblclick(x, y)
-
-    async def _scroll(self, x: int, y: int, scroll_x: int, scroll_y: int) -> None:
-        """Scroll from coordinates."""
-        self._ensure_started()
-        await self._page.mouse.move(x, y)
-        await self._page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
-
-    async def _type(self, text: str) -> None:
-        """Type text."""
-        self._ensure_started()
-        await self._page.keyboard.type(text)
-
-    async def _keypress(self, keys: List[str]) -> None:
-        """Press key combination."""
-        self._ensure_started()
-        mapped_keys = [CUA_KEY_TO_PLAYWRIGHT_KEY.get(key.lower(), key) for key in keys]
-        for key in mapped_keys:
-            await self._page.keyboard.down(key)
-        for key in reversed(mapped_keys):
-            await self._page.keyboard.up(key)
-
-    async def _move(self, x: int, y: int) -> None:
-        """Move mouse to coordinates."""
-        self._ensure_started()
-        await self._page.mouse.move(x, y)
-
-    async def _drag(self, path: List[Dict[str, int]]) -> None:
-        """Drag mouse along path."""
-        self._ensure_started()
-        if not path:
-            return
-        await self._page.mouse.move(path[0]["x"], path[0]["y"])
-        await self._page.mouse.down()
-        for point in path[1:]:
-            await self._page.mouse.move(point["x"], point["y"])
-        await self._page.mouse.up()
-
-    async def _wait(self, ms: int = 1000) -> None:
-        """Wait for specified milliseconds."""
-        import asyncio
-
-        await asyncio.sleep(ms / 1000)
-
-    # Browser-specific actions
-    async def _goto(self, url: str) -> None:
-        """Navigate to URL."""
-        self._ensure_started()
-        try:
-            await self._page.goto(url)
-        except Exception as e:
-            print(f"Error navigating to {url}: {e}")
-
-    async def _back(self) -> None:
-        """Go back in browser history."""
-        self._ensure_started()
-        await self._page.go_back()
-
-    async def _forward(self) -> None:
-        """Go forward in browser history."""
-        self._ensure_started()
-        await self._page.go_forward()
-
-    async def _refresh(self) -> None:
-        """Refresh the page."""
-        self._ensure_started()
-        await self._page.reload()
-
-    # ------------------------------------------------------------------
-    # Public aliases (no leading underscore) expected by the Agent &
-    # OpenAI computer-use API. They forward directly to the underscored
-    # implementations above so the external interface matches the older
-    # BasePlaywrightComputer class.
-    # ------------------------------------------------------------------
-
-    # Mouse / keyboard actions
-    click = _click
-    double_click = _double_click
-    scroll = _scroll
-    type = _type  # noqa: A003 – shadowing built-in for API compatibility
-    keypress = _keypress
-    move = _move
-    drag = _drag
-    wait = _wait
-
-    # Browser navigation actions
-    goto = _goto
-    back = _back
-    forward = _forward
-    refresh = _refresh

fleet/playwright.py

@@ -1,290 +0,0 @@
-import base64
-from typing import List, Dict, Any
-from playwright.sync_api import sync_playwright, Browser, Page
-from .client import Environment
-
-
-# Key mapping for computer use actions
-CUA_KEY_TO_PLAYWRIGHT_KEY = {
-    "/": "Divide",
-    "\\": "Backslash",
-    "alt": "Alt",
-    "arrowdown": "ArrowDown",
-    "arrowleft": "ArrowLeft",
-    "arrowright": "ArrowRight",
-    "arrowup": "ArrowUp",
-    "backspace": "Backspace",
-    "capslock": "CapsLock",
-    "cmd": "Meta",
-    "ctrl": "Control",
-    "delete": "Delete",
-    "end": "End",
-    "enter": "Enter",
-    "esc": "Escape",
-    "home": "Home",
-    "insert": "Insert",
-    "option": "Alt",
-    "pagedown": "PageDown",
-    "pageup": "PageUp",
-    "shift": "Shift",
-    "space": " ",
-    "super": "Meta",
-    "tab": "Tab",
-    "win": "Meta",
-}
-
-
-class FleetPlaywrightWrapper:
-    """
-    A wrapper that adds Playwright browser automation to Fleet environment instances.
-
-    This class handles:
-    - Browser connection via CDP
-    - Computer actions (click, scroll, type, etc.)
-    - Screenshot capture
-    - Integration with OpenAI computer use API
-
-    Usage:
-        instance = fleet.env.make(env_key="hubspot", version="v1.2.7")
-        browser = FleetPlaywrightWrapper(instance)
-        browser.start()
-
-        # Use browser methods
-        screenshot = browser.screenshot()
-        tools = [browser.openai_cua_tool]
-
-        # Clean up when done
-        browser.close()
-    """
-
-    def get_environment(self):
-        return "browser"
-
-    def get_dimensions(self):
-        return (1920, 1080)
-
-    def __init__(
-        self,
-        env: Environment,
-        display_width: int = 1920,
-        display_height: int = 1080,
-    ):
-        """
-        Initialize the Fleet Playwright wrapper.
-
-        Args:
-            env: Fleet environment instance
-            display_width: Browser viewport width
-            display_height: Browser viewport height
-        """
-        self.env = env
-        self.display_width = display_width
-        self.display_height = display_height
-
-        self._playwright = None
-        self._browser: Browser | None = None
-        self._page: Page | None = None
-        self._started = False
-
-    def start(self):
-        """Start the browser and establish connection."""
-        if self._started:
-            return
-
-        # Start Playwright
-        self._playwright = sync_playwright().start()
-
-        # Start browser on the Fleet instance
-        print("Starting browser...")
-        self.env.browser().start()
-        cdp = self.env.browser().describe()
-
-        # Connect to browser
-        self._browser = self._playwright.chromium.connect_over_cdp(
-            cdp.cdp_browser_url
-        )
-        self._page = self._browser.contexts[0].pages[0]
-        self._page.set_viewport_size(
-            {"width": self.display_width, "height": self.display_height}
-        )
-
-        self._started = True
-        print(f"Track agent: {cdp.cdp_devtools_url}")
-
-    def close(self):
-        """Close the browser connection."""
-        if self._playwright:
-            self._playwright.stop()
-            self._playwright = None
-            self._browser = None
-            self._page = None
-            self._started = False
-
-    def _ensure_started(self):
-        """Ensure browser is started before operations."""
-        if not self._started:
-            raise RuntimeError("Browser not started. Call browser.start() first.")
-
-    @property
-    def openai_cua_tool(self) -> Dict[str, Any]:
-        """
-        Tool definition for OpenAI computer use API.
-
-        Returns:
-            Tool definition dict for use with OpenAI responses API
-        """
-        return {
-            "type": "computer_use_preview",
-            "display_width": self.display_width,
-            "display_height": self.display_height,
-            "environment": "browser",
-        }
-
-    def screenshot(self) -> str:
-        """
-        Take a screenshot and return base64 encoded string.
-
-        Returns:
-            Base64 encoded PNG screenshot
-        """
-        self._ensure_started()
-
-        png_bytes = self._page.screenshot(full_page=False)
-        return base64.b64encode(png_bytes).decode("utf-8")
-
-    def get_current_url(self) -> str:
-        """Get the current page URL."""
-        self._ensure_started()
-        return self._page.url
-
-    def execute_computer_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Execute a computer action and return the result for OpenAI API.
-
-        Args:
-            action: Computer action dict from OpenAI response
-
-        Returns:
-            Result dict for computer_call_output
-        """
-        self._ensure_started()
-
-        action_type = action["type"]
-        action_args = {k: v for k, v in action.items() if k != "type"}
-
-        print(f"Executing: {action_type}({action_args})")
-
-        # Execute the action
-        if hasattr(self, f"_{action_type}"):
-            method = getattr(self, f"_{action_type}")
-            method(**action_args)
-        else:
-            raise ValueError(f"Unsupported action type: {action_type}")
-
-        # Take screenshot after action
-        screenshot_base64 = self.screenshot()
-
-        return {
-            "type": "input_image",
-            "image_url": f"data:image/png;base64,{screenshot_base64}",
-            "current_url": self.get_current_url(),
-        }
-
-    # Computer action implementations
-    def _click(self, x: int, y: int, button: str = "left") -> None:
-        """Click at coordinates."""
-        self._ensure_started()
-        self._page.mouse.click(x, y, button=button)
-
-    def _double_click(self, x: int, y: int) -> None:
-        """Double-click at coordinates."""
-        self._ensure_started()
-        self._page.mouse.dblclick(x, y)
-
-    def _scroll(self, x: int, y: int, scroll_x: int, scroll_y: int) -> None:
-        """Scroll from coordinates."""
-        self._ensure_started()
-        self._page.mouse.move(x, y)
-        self._page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
-
-    def _type(self, text: str) -> None:
-        """Type text."""
-        self._ensure_started()
-        self._page.keyboard.type(text)
-
-    def _keypress(self, keys: List[str]) -> None:
-        """Press key combination."""
-        self._ensure_started()
-        mapped_keys = [CUA_KEY_TO_PLAYWRIGHT_KEY.get(key.lower(), key) for key in keys]
-        for key in mapped_keys:
-            self._page.keyboard.down(key)
-        for key in reversed(mapped_keys):
-            self._page.keyboard.up(key)
-
-    def _move(self, x: int, y: int) -> None:
-        """Move mouse to coordinates."""
-        self._ensure_started()
-        self._page.mouse.move(x, y)
-
-    def _drag(self, path: List[Dict[str, int]]) -> None:
-        """Drag mouse along path."""
-        self._ensure_started()
-        if not path:
-            return
-        self._page.mouse.move(path[0]["x"], path[0]["y"])
-        self._page.mouse.down()
-        for point in path[1:]:
-            self._page.mouse.move(point["x"], point["y"])
-        self._page.mouse.up()
-
-    def _wait(self, ms: int = 1000) -> None:
-        """Wait for specified milliseconds."""
-
-        time.sleep(ms / 1000)
-
-    # Browser-specific actions
-    def _goto(self, url: str) -> None:
-        """Navigate to URL."""
-        self._ensure_started()
-        try:
-            self._page.goto(url)
-        except Exception as e:
-            print(f"Error navigating to {url}: {e}")
-
-    def _back(self) -> None:
-        """Go back in browser history."""
-        self._ensure_started()
-        self._page.go_back()
-
-    def _forward(self) -> None:
-        """Go forward in browser history."""
-        self._ensure_started()
-        self._page.go_forward()
-
-    def _refresh(self) -> None:
-        """Refresh the page."""
-        self._ensure_started()
-        self._page.reload()
-
-    # ------------------------------------------------------------------
-    # Public aliases (no leading underscore) expected by the Agent &
-    # OpenAI computer-use API. They forward directly to the underscored
-    # implementations above so the external interface matches the older
-    # BasePlaywrightComputer class.
-    # ------------------------------------------------------------------
-
-    # Mouse / keyboard actions
-    click = _click
-    double_click = _double_click
-    scroll = _scroll
-    type = _type  # noqa: A003 – shadowing built-in for API compatibility
-    keypress = _keypress
-    move = _move
-    drag = _drag
-    wait = _wait
-
-    # Browser navigation actions
-    goto = _goto
-    back = _back
-    forward = _forward
-    refresh = _refresh