fleet-python 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

fleet/playwright.py

@@ -0,0 +1,289 @@
+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 = await fleet.env.make(env_key="hubspot", version="v1.2.7")
+        browser = FleetPlaywrightWrapper(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: 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 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",
+        }
+
+    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."""
+        import asyncio
+
+        asyncio.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

fleet/resources/base.py

@@ -1,5 +1,5 @@
 from abc import ABC
-from ..manager.models import Resource as ResourceModel, ResourceType, ResourceMode
+from ..instance.models import Resource as ResourceModel, ResourceType, ResourceMode
 
 
 class Resource(ABC):

fleet/resources/browser.py

@@ -1,5 +1,5 @@
 from typing import Optional
-from ..manager.models import (
+from ..instance.models import (
     Resource as ResourceModel,
     CDPDescribeResponse,
     ChromeStartRequest,
@@ -10,35 +10,32 @@ from .base import Resource
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ..manager.base import AsyncWrapper
+    from ..instance.base import SyncWrapper
 
 
-class AsyncBrowserResource(Resource):
-    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
+class BrowserResource(Resource):
+    def __init__(self, resource: ResourceModel, client: "SyncWrapper"):
         super().__init__(resource)
         self.client = client
-        self._describe: Optional[CDPDescribeResponse] = None
 
-    async def start(self, width: int = 1920, height: int = 1080) -> CDPDescribeResponse:
-        response = await self.client.request(
+    def start(self, width: int = 1920, height: int = 1080) -> CDPDescribeResponse:
+        response = self.client.request(
             "POST",
             "/resources/cdp/start",
             json=ChromeStartRequest(resolution=f"{width},{height}").model_dump(),
         )
         ChromeStartResponse(**response.json())
-        return await self.describe()
-
-    async def describe(self) -> CDPDescribeResponse:
-        if self._describe is None:
-            response = await self.client.request("GET", "/resources/cdp/describe")
-            if response.status_code != 200:
-                await self.start()
-                response = await self.client.request("GET", "/resources/cdp/describe")
-            self._describe = CDPDescribeResponse(**response.json())
-        return self._describe
-
-    async def cdp_url(self) -> str:
-        return (await self.describe()).cdp_browser_url
-
-    async def devtools_url(self) -> str:
-        return (await self.describe()).cdp_devtools_url
+        return self.describe()
+
+    def describe(self) -> CDPDescribeResponse:
+        response = self.client.request("GET", "/resources/cdp/describe")
+        if response.status_code != 200:
+            self.start()
+            response = self.client.request("GET", "/resources/cdp/describe")
+        return CDPDescribeResponse(**response.json())
+
+    def cdp_url(self) -> str:
+        return (self.describe()).cdp_browser_url
+
+    def devtools_url(self) -> str:
+        return (self.describe()).cdp_devtools_url

fleet/resources/sqlite.py

@@ -1,39 +1,39 @@
 from typing import Any, List, Optional
-from ..manager.models import Resource as ResourceModel
-from ..manager.models import DescribeResponse, QueryRequest, QueryResponse
+from ..instance.models import Resource as ResourceModel
+from ..instance.models import DescribeResponse, QueryRequest, QueryResponse
 from .base import Resource
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ..manager.base import AsyncWrapper
+    from ..instance.base import SyncWrapper
 
 
-class AsyncSQLiteResource(Resource):
-    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
+class SQLiteResource(Resource):
+    def __init__(self, resource: ResourceModel, client: "SyncWrapper"):
         super().__init__(resource)
         self.client = client
 
-    async def describe(self) -> DescribeResponse:
+    def describe(self) -> DescribeResponse:
         """Describe the SQLite database schema."""
-        response = await self.client.request(
+        response = self.client.request(
             "GET", f"/resources/sqlite/{self.resource.name}/describe"
         )
         return DescribeResponse(**response.json())
 
-    async def query(
+    def query(
         self, query: str, args: Optional[List[Any]] = None
     ) -> QueryResponse:
-        return await self._query(query, args, read_only=True)
+        return self._query(query, args, read_only=True)
 
-    async def exec(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
-        return await self._query(query, args, read_only=False)
+    def exec(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
+        return self._query(query, args, read_only=False)
 
-    async def _query(
+    def _query(
         self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
     ) -> QueryResponse:
         request = QueryRequest(query=query, args=args, read_only=read_only)
-        response = await self.client.request(
+        response = self.client.request(
             "POST",
             f"/resources/sqlite/{self.resource.name}/query",
             json=request.model_dump(),

fleet/verifiers/__init__.py

@@ -1,4 +1,11 @@
-from .database_snapshot import QueryBuilder, DatabaseSnapshot
-from .sql_differ import SQLiteDiffer
+"""Fleet verifiers module - database snapshot validation utilities."""
 
-__all__ = ["QueryBuilder", "DatabaseSnapshot", "SQLiteDiffer"]
+from .db import DatabaseSnapshot, IgnoreConfig, SnapshotDiff
+from .code import TASK_SUCCESSFUL_SCORE
+
+__all__ = [
+    "DatabaseSnapshot",
+    "IgnoreConfig",
+    "SnapshotDiff",
+    "TASK_SUCCESSFUL_SCORE",
+]

fleet/verifiers/code.py

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

fleet/verifiers/{database_snapshot.py → db.py}

@@ -1,4 +1,3 @@
-# database_dsl.py
 """A schema‑agnostic, SQL‑native DSL for snapshot validation and diff invariants.
 
 The module extends your original `DatabaseSnapshot` implementation with
@@ -11,11 +10,13 @@ The module extends your original `DatabaseSnapshot` implementation with
 The public API stays tiny yet composable; everything else is built on
 orthogonal primitives so it works for *any* relational schema.
 """
+
 from __future__ import annotations
 
 import sqlite3
 from datetime import datetime
 from typing import Any
+import json
 
 ################################################################################
 #  Low‑level helpers
@@ -26,6 +27,36 @@ Condition = tuple[str, str, SQLValue]  # (column, op, value)
 JoinSpec = tuple[str, dict[str, str]]  # (table, on mapping)
 
 
+def _is_json_string(value: Any) -> bool:
+    """Check if a value looks like a JSON string."""
+    if not isinstance(value, str):
+        return False
+    value = value.strip()
+    return (value.startswith("{") and value.endswith("}")) or (
+        value.startswith("[") and value.endswith("]")
+    )
+
+
+def _values_equivalent(val1: Any, val2: Any) -> bool:
+    """Compare two values, using JSON semantic comparison for JSON strings."""
+    # If both are exactly equal, return True
+    if val1 == val2:
+        return True
+
+    # If both look like JSON strings, try semantic comparison
+    if _is_json_string(val1) and _is_json_string(val2):
+        try:
+            parsed1 = json.loads(val1)
+            parsed2 = json.loads(val2)
+            return parsed1 == parsed2
+        except (json.JSONDecodeError, TypeError):
+            # If parsing fails, fall back to string comparison
+            pass
+
+    # Default to exact comparison
+    return val1 == val2
+
+
 class _CountResult:
     """Wraps an integer count so we can chain assertions fluently."""
 
@@ -96,9 +127,7 @@ class QueryBuilder:
     # ---------------------------------------------------------------------
     #  WHERE helpers (SQL‑like)
     # ---------------------------------------------------------------------
-    def _add_condition(
-        self, column: str, op: str, value: SQLValue
-    ) -> "QueryBuilder":  # noqa: UP037
+    def _add_condition(self, column: str, op: str, value: SQLValue) -> "QueryBuilder":  # noqa: UP037
         qb = self._clone()
         qb._conditions.append((column, op, value))
         return qb
@@ -126,9 +155,7 @@ class QueryBuilder:
         qb._conditions.append((column, "IN", tuple(values)))
         return qb
 
-    def not_in(
-        self, column: str, values: list[SQLValue]
-    ) -> "QueryBuilder":  # noqa: UP037
+    def not_in(self, column: str, values: list[SQLValue]) -> "QueryBuilder":  # noqa: UP037
         qb = self._clone()
         qb._conditions.append((column, "NOT IN", tuple(values)))
         return qb
@@ -147,9 +174,7 @@ class QueryBuilder:
     # ---------------------------------------------------------------------
     #  JOIN (simple inner join)
     # ---------------------------------------------------------------------
-    def join(
-        self, other_table: str, on: dict[str, str]
-    ) -> "QueryBuilder":  # noqa: UP037
+    def join(self, other_table: str, on: dict[str, str]) -> "QueryBuilder":  # noqa: UP037
         """`on` expects {local_col: remote_col}."""
         qb = self._clone()
         qb._joins.append((other_table, on))
@@ -166,7 +191,8 @@ class QueryBuilder:
         # Joins -------------------------------------------------------------
         for tbl, onmap in self._joins:
             join_clauses = [
-                f"{self._table}.{l} = {tbl}.{r}" for l, r in onmap.items()  # noqa: E741
+                f"{self._table}.{l} = {tbl}.{r}"
+                for l, r in onmap.items()  # noqa: E741
             ]
             sql.append(f"JOIN {tbl} ON {' AND '.join(join_clauses)}")
 
@@ -430,10 +456,27 @@ class SnapshotDiff:
     def expect_only(self, allowed_changes: list[dict[str, Any]]):
         """Allowed changes is a list of {table, pk, field, after} (before optional)."""
         diff = self._collect()
-        allowed_set = {
-            (c["table"], c.get("pk"), c.get("field"), c.get("after"))
-            for c in allowed_changes
-        }
+
+        def _is_change_allowed(
+            table: str, row_id: str, field: str | None, after_value: Any
+        ) -> bool:
+            """Check if a change is in the allowed list using semantic comparison."""
+            for allowed in allowed_changes:
+                allowed_pk = allowed.get("pk")
+                # Handle type conversion for primary key comparison
+                # Convert both to strings for comparison to handle int/string mismatches
+                pk_match = (
+                    str(allowed_pk) == str(row_id) if allowed_pk is not None else False
+                )
+
+                if (
+                    allowed["table"] == table
+                    and pk_match
+                    and allowed.get("field") == field
+                    and _values_equivalent(allowed.get("after"), after_value)
+                ):
+                    return True
+            return False
 
         # Collect all unexpected changes for detailed reporting
         unexpected_changes = []
@@ -443,8 +486,7 @@ class SnapshotDiff:
                 for f, vals in row["changes"].items():
                     if self.ignore_config.should_ignore_field(tbl, f):
                         continue
-                    tup = (tbl, row["row_id"], f, vals["after"])
-                    if tup not in allowed_set:
+                    if not _is_change_allowed(tbl, row["row_id"], f, vals["after"]):
                         unexpected_changes.append(
                             {
                                 "type": "modification",
@@ -458,8 +500,7 @@ class SnapshotDiff:
                         )
 
             for row in report.get("added_rows", []):
-                tup = (tbl, row["row_id"], None, "__added__")
-                if tup not in allowed_set:
+                if not _is_change_allowed(tbl, row["row_id"], None, "__added__"):
                     unexpected_changes.append(
                         {
                             "type": "insertion",
@@ -472,8 +513,7 @@ class SnapshotDiff:
                     )
 
             for row in report.get("removed_rows", []):
-                tup = (tbl, row["row_id"], None, "__removed__")
-                if tup not in allowed_set:
+                if not _is_change_allowed(tbl, row["row_id"], None, "__removed__"):
                     unexpected_changes.append(
                         {
                             "type": "deletion",
@@ -663,4 +703,4 @@ class DatabaseSnapshot:
 
     # ---------------------------------------------------------------------
     def __repr__(self):
-        return f"<DatabaseSnapshot {self.name} at {self.db_path}>"
+        return f"<DatabaseSnapshot {self.name} at {self.db_path}>"

fleet/verifiers/sql_differ.py

@@ -184,4 +184,4 @@ class SQLiteDiffer:
             except Exception as e:
                 results[table] = {"error": str(e)}
 
-        return results
+        return results

{fleet_python-0.2.2.dist-info → fleet_python-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.2
+Version: 0.2.4
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0
@@ -31,6 +31,9 @@ Requires-Dist: black>=22.0.0; extra == "dev"
 Requires-Dist: isort>=5.0.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: unasync>=0.6.0; extra == "dev"
+Provides-Extra: playwright
+Requires-Dist: playwright>=1.40.0; extra == "playwright"
 Dynamic: license-file
 
 # Fleet SDK

fleet_python-0.2.4.dist-info/RECORD

@@ -0,0 +1,48 @@
+examples/dsl_example.py,sha256=nBfKdv4u6XuM97TG-ugfVStPdtoYq86ildFzLcQqGIk,5315
+examples/example.py,sha256=B1ERVudPsPx1D1od3gCQU8MnG4FxuSBm0p7otkvIaLw,945
+examples/json_tasks_example.py,sha256=_y4w94FfAaMBGgIqhVlrDU0PXbinNDWrT28DsUMvd9Y,2354
+examples/nova_act_example.py,sha256=YMfx_7O1_6pqsy0Rf6Yabyqyg4_kI3cgMBlMJjAQXW4,790
+examples/openai_example.py,sha256=5ZvBC0dcw8gPHoC6Gn-1KZx3CmUQBlBmPJgOrcgMSVM,8188
+examples/openai_simple_example.py,sha256=pS2z7Q3s7tml5hbahc1NGgMXoF0mWwhi7VeLDTA4sE4,1702
+examples/quickstart.py,sha256=lVRzbnWIweU9ioe7uk6R2Rm7oSpt4mt8Jq_VUUp1zKg,4696
+fleet/__init__.py,sha256=CxDokocjQsv_JUNwhSqnijpQVXhQx73CXLu2Cp-rtgk,2087
+fleet/base.py,sha256=t4xkgazl8kEP05JFjNByyf39RvvASRP0GsvxuoqKPY0,1395
+fleet/client.py,sha256=SQEUoj4DMuXa4m5wfPPCkBEhQc7f6941K9V8Qk6ZF0U,4675
+fleet/exceptions.py,sha256=yG3QWprCw1OnF-vdFBFJWE4m3ftBLBng31Dr__VbjI4,2249
+fleet/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
+fleet/playwright.py,sha256=LWx_1UlNZPo117Lf7qnBlWT4RJA0OcwqRVRdFE98bSQ,8627
+fleet/_async/base.py,sha256=hUch1I5oUPgaCXR3IpJ8f_PjigifAZg2-LR7BJdZSo8,1413
+fleet/_async/client.py,sha256=pL0csdrAJKltA9km6DHDRogPpTEzi8AH32mS1efxNgg,4920
+fleet/_async/exceptions.py,sha256=yG3QWprCw1OnF-vdFBFJWE4m3ftBLBng31Dr__VbjI4,2249
+fleet/_async/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
+fleet/_async/playwright.py,sha256=5MLFPE5P_-MpzAQ3EJ6GsLthuJiWwYkNuvhPE_rwe_E,8914
+fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fleet/_async/env/client.py,sha256=Gft6pNkUK4PYMV8VE3KyS5R_-HuqGO5HEjAUuCPObiw,440
+fleet/_async/instance/__init__.py,sha256=jIt-7EEJ0WM_ipheT_s0lniCbLei6yUdN0qQv1bMJ3E,524
+fleet/_async/instance/base.py,sha256=QgcCTHdcqhi5VQi6_a1uuR-uO2_2Z19-RwVPp1k266A,947
+fleet/_async/instance/client.py,sha256=Llc-yefnbL3fkBsayU4ANEqy_fFB2Uy6jNhTkfGj1mU,9362
+fleet/_async/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
+fleet/_async/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fleet/_async/resources/base.py,sha256=203gD54NP1IvjuSqFo-f7FvrkhtjChggtzrxJK7xf2E,667
+fleet/_async/resources/browser.py,sha256=x11y4aKHogIEv83FByHtExerjV-cDWI3U62349Guq_Q,1368
+fleet/_async/resources/sqlite.py,sha256=sRiII_qJ8X6-FSemlBsXThz4ZPjkNy9wDT8g5UAz2XM,1501
+fleet/env/__init__.py,sha256=_lvYBqieXWmvU_dyPi2seSpLO3AZh5kdprdqFeefkzk,338
+fleet/env/client.py,sha256=UGPrRlu89NM2RFdY7m6cGwUjOHJdtiPe4vkz-f2ByRg,351
+fleet/instance/__init__.py,sha256=cdVC50HLLp2y7yf1Ga5wpLiy-hmamxmyibH0NDG7xI4,597
+fleet/instance/base.py,sha256=U-qW1EQVBo6yvMpP1JeKiPRhCjZ3y3aTsYFhLPNOTtQ,929
+fleet/instance/client.py,sha256=RFp5R703pP3tjKd_HBozJJ2qNie7LpMUx9NYjyPnPOI,9128
+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=hRNM0YMsVQUAraZGNi_B-KXxLpuddy4ntoEDFSw7czU,1295
+fleet/resources/sqlite.py,sha256=sZVWsuq46ger-ta6PSlqcXGJG8iWpNQVj0CPmDNBXv8,1446
+fleet/verifiers/__init__.py,sha256=mRMN8x0gDWFJ1MRLqdBtQw0gn_q8kDV3lMLyoiEf1yY,281
+fleet/verifiers/code.py,sha256=NJ4OLZnpqLkI1lXY7-5m2GuZklLxMzHUCnRMVyN2_OI,25
+fleet/verifiers/db.py,sha256=tssmvJjDHuBIy8qlL_P5-UdmEFUw2DZcqLsWZ8ot3Xw,27766
+fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
+fleet_python-0.2.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scripts/unasync.py,sha256=--Fmaae47o-dZ1HYgX1c3Nvi-rMjcFymTRlJcWWnmpw,725
+fleet_python-0.2.4.dist-info/METADATA,sha256=WbcSC3GkduODoS30lm4TE1YMX6WEJ92HdMwHb-igUR4,3199
+fleet_python-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.4.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.4.dist-info/RECORD,,

{fleet_python-0.2.2.dist-info → fleet_python-0.2.4.dist-info}/top_level.txt

@@ -1,2 +1,3 @@
 examples
 fleet
+scripts