fleet-python 0.2.106__tar.gz → 0.2.108__tar.gz

{fleet_python-0.2.106/fleet_python.egg-info → fleet_python-0.2.108}/PKG-INFO

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

{fleet_python-0.2.106 → fleet_python-0.2.108}/fleet/__init__.py

@@ -73,7 +73,7 @@ from . import env
 from . import global_client as _global_client
 from ._async import global_client as _async_global_client
 
-__version__ = "0.2.103"
+__version__ = "0.2.108"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.106 → fleet_python-0.2.108}/fleet/_async/__init__.py

@@ -44,7 +44,7 @@ from ..types import VerifierFunction
 from .. import env
 from . import global_client as _async_global_client
 
-__version__ = "0.2.103"
+__version__ = "0.2.108"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.106 → fleet_python-0.2.108}/fleet/_async/base.py

@@ -26,7 +26,7 @@ from .exceptions import (
 try:
     from .. import __version__
 except ImportError:
-    __version__ = "0.2.103"
+    __version__ = "0.2.108"
 
 logger = logging.getLogger(__name__)
 

{fleet_python-0.2.106 → fleet_python-0.2.108}/fleet/_async/client.py

@@ -171,6 +171,7 @@ from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import AsyncSQLiteResource
 from .resources.browser import AsyncBrowserResource
+from .resources.filesystem import AsyncFilesystemResource
 from .resources.mcp import AsyncMCPResource
 from .resources.api import AsyncAPIResource
 
@@ -386,6 +387,10 @@ class AsyncEnv(EnvironmentBase):
     def browser(self, name: str = "cdp") -> AsyncBrowserResource:
         return self.instance.browser(name)
 
+    def fs(self) -> AsyncFilesystemResource:
+        """Get a filesystem diff resource for inspecting file changes."""
+        return self.instance.fs()
+
     def api(self, name: str = "api") -> AsyncAPIResource:
         """Get an API resource for making HTTP requests to the app's API.
 
@@ -1270,8 +1275,6 @@ class AsyncFleet:
         prompt: Optional[str] = None,
         verifier_code: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
-        writer_metadata: Optional[Dict[str, Any]] = None,
-        qa_metadata: Optional[Dict[str, Any]] = None,
     ) -> TaskResponse:
         """Update an existing task.
 
@@ -1280,19 +1283,11 @@ class AsyncFleet:
             prompt: New prompt text for the task (optional)
             verifier_code: Python code for task verification (optional)
             metadata: Additional metadata for the task (optional)
-            writer_metadata: Metadata filled by task writer (optional)
-            qa_metadata: Metadata filled by QA reviewer (optional)
 
         Returns:
             TaskResponse containing the updated task details
         """
-        payload = TaskUpdateRequest(
-            prompt=prompt,
-            verifier_code=verifier_code,
-            metadata=metadata,
-            writer_metadata=writer_metadata,
-            qa_metadata=qa_metadata,
-        )
+        payload = TaskUpdateRequest(prompt=prompt, verifier_code=verifier_code, metadata=metadata)
         response = await self.client.request(
             "PUT", f"/v1/tasks/{task_key}", json=payload.model_dump(exclude_none=True)
         )

{fleet_python-0.2.106 → fleet_python-0.2.108}/fleet/_async/instance/client.py

@@ -10,6 +10,7 @@ from urllib.parse import urlparse
 from ..resources.sqlite import AsyncSQLiteResource
 from ..resources.browser import AsyncBrowserResource
 from ..resources.api import AsyncAPIResource
+from ..resources.filesystem import AsyncFilesystemResource
 from ..resources.base import Resource
 
 from fleet.verifiers import DatabaseSnapshot
@@ -105,6 +106,19 @@ class AsyncInstanceClient:
             self._resources_state[ResourceType.cdp.value][name], self.client
         )
 
+    def fs(self) -> AsyncFilesystemResource:
+        """Returns a filesystem diff resource for inspecting file changes.
+
+        Returns:
+            An AsyncFilesystemResource for querying filesystem diffs
+        """
+        resource_model = ResourceModel(
+            name="fs",
+            type=ResourceType.db,  # Reuse existing type; fs is not a registered resource type
+            mode=ResourceMode.ro,
+        )
+        return AsyncFilesystemResource(resource_model, self.client)
+
     def api(self, name: str, base_url: str) -> AsyncAPIResource:
         """
         Returns an API resource for making HTTP requests.

{fleet_python-0.2.106 → fleet_python-0.2.108}/fleet/_async/models.py

@@ -157,9 +157,6 @@ class TaskRequest(BaseModel):
     version: Optional[str] = Field(None, title="Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
     metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
-    writer_metadata: Optional[Dict[str, Any]] = Field(
-        None, title="Writer Metadata", description="Metadata filled by task writer"
-    )
     output_json_schema: Optional[Dict[str, Any]] = Field(None, title="Output Json Schema")
 
 
@@ -167,12 +164,6 @@ class TaskUpdateRequest(BaseModel):
     prompt: Optional[str] = Field(None, title="Prompt")
     verifier_code: Optional[str] = Field(None, title="Verifier Code")
     metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
-    writer_metadata: Optional[Dict[str, Any]] = Field(
-        None, title="Writer Metadata", description="Metadata filled by task writer"
-    )
-    qa_metadata: Optional[Dict[str, Any]] = Field(
-        None, title="QA Metadata", description="Metadata filled by QA reviewer"
-    )
 
 
 class VerifierData(BaseModel):

fleet_python-0.2.108/fleet/_async/resources/filesystem.py

@@ -0,0 +1,397 @@
+from typing import Any, Dict, List, Optional
+from ...instance.models import (
+    Resource as ResourceModel,
+    FsDiffRequest,
+    FsDiffResponse,
+    FsFileDiffEntry,
+    FileStateRequest,
+    FileStateResponse,
+    FileStateTextRequest,
+    DocTextRequest,
+    DocMetadataRequest,
+    DocMetadataResponse,
+    DocStructuredRequest,
+    DocStructuredResponse,
+)
+from .base import Resource
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..instance.base import AsyncWrapper
+
+
+# Document extensions that need /fs/doc/text for readable content extraction
+_DOC_EXTENSIONS = {
+    ".docx", ".doc", ".pptx", ".ppt", ".xlsx", ".xls",
+    ".odt", ".ods", ".odp", ".rtf", ".pdf", ".epub",
+}
+
+
+def _is_doc_file(path: str) -> bool:
+    lower = path.lower()
+    return any(lower.endswith(ext) for ext in _DOC_EXTENSIONS)
+
+
+class AsyncFilesystemDiff:
+    """Wraps a filesystem diff response with assertion helpers."""
+
+    def __init__(self, response: FsDiffResponse, resource: "AsyncFilesystemResource"):
+        self.response = response
+        self.files = response.files
+        self.total_files = response.total_files
+        self.total_size = response.total_size
+        self._resource = resource
+
+    def _files_by_path(self) -> Dict[str, FsFileDiffEntry]:
+        return {f.path: f for f in self.files}
+
+    def expect_no_changes(self) -> "AsyncFilesystemDiff":
+        """Assert that no filesystem changes occurred."""
+        if self.files:
+            paths = [f.path for f in self.files]
+            raise AssertionError(
+                f"Expected no filesystem changes, but found {len(self.files)} changed file(s):\n"
+                + "\n".join(f"  - {p}" for p in paths)
+            )
+        return self
+
+    async def expect_only(self, allowed_changes: List[Dict[str, Any]]) -> "AsyncFilesystemDiff":
+        """Assert that only the specified filesystem changes occurred.
+
+        Each spec in allowed_changes is a dict with:
+            - "path" (required): the file path to expect
+            - "content" (optional): expected file content (exact match)
+            - "content_contains" (optional): substring that must appear in content
+            - "doc_text" (optional): expected extracted text from doc files (exact match)
+            - "doc_text_contains" (optional): substring that must appear in doc text
+            - "file_type" (optional): expected file_type value
+            - "size" (optional): expected file size
+
+        Use ... (Ellipsis) as a value to accept any value for that field.
+
+        For document files (docx, pptx, xlsx, etc.), use doc_text / doc_text_contains
+        instead of content / content_contains. These call /fs/doc/text to extract
+        readable text from binary document formats.
+
+        Raises:
+            AssertionError: if unexpected files changed or specs don't match
+        """
+        if not allowed_changes:
+            return self.expect_no_changes()
+
+        files_by_path = self._files_by_path()
+        allowed_paths = set()
+        errors: List[str] = []
+
+        for spec in allowed_changes:
+            path = spec.get("path")
+            if path is None:
+                raise ValueError("Each allowed change spec must include a 'path' key")
+            allowed_paths.add(path)
+
+            if path not in files_by_path:
+                errors.append(f"Expected change at '{path}' but file was not in diff")
+                continue
+
+            entry = files_by_path[path]
+            await self._validate_entry(entry, spec, errors)
+
+        # Check for unexpected changes
+        unexpected = set(files_by_path.keys()) - allowed_paths
+        if unexpected:
+            errors.append(
+                f"Unexpected filesystem changes ({len(unexpected)} file(s)):\n"
+                + "\n".join(f"  - {p}" for p in sorted(unexpected))
+            )
+
+        if errors:
+            raise AssertionError(
+                f"Filesystem expect_only failed with {len(errors)} error(s):\n"
+                + "\n".join(f"  {i+1}. {e}" for i, e in enumerate(errors))
+            )
+
+        return self
+
+    async def expect_exactly(self, expected_changes: List[Dict[str, Any]]) -> "AsyncFilesystemDiff":
+        """Assert that EXACTLY the specified filesystem changes occurred.
+
+        Like expect_only, but also fails if an expected path is missing from the diff.
+        See expect_only for the full spec format including doc_text / doc_text_contains.
+
+        Raises:
+            AssertionError: if changes don't match exactly
+        """
+        if not expected_changes and self.files:
+            paths = [f.path for f in self.files]
+            raise AssertionError(
+                f"Expected no filesystem changes, but found {len(self.files)} changed file(s):\n"
+                + "\n".join(f"  - {p}" for p in paths)
+            )
+
+        files_by_path = self._files_by_path()
+        expected_paths = set()
+        errors: List[str] = []
+
+        for spec in expected_changes:
+            path = spec.get("path")
+            if path is None:
+                raise ValueError("Each expected change spec must include a 'path' key")
+            expected_paths.add(path)
+
+            if path not in files_by_path:
+                errors.append(f"Expected change at '{path}' but file was not in diff")
+                continue
+
+            entry = files_by_path[path]
+            await self._validate_entry(entry, spec, errors)
+
+        # Check for unexpected changes
+        unexpected = set(files_by_path.keys()) - expected_paths
+        if unexpected:
+            errors.append(
+                f"Unexpected filesystem changes ({len(unexpected)} file(s)):\n"
+                + "\n".join(f"  - {p}" for p in sorted(unexpected))
+            )
+
+        # Check for missing expected changes
+        missing = expected_paths - set(files_by_path.keys())
+        if missing:
+            errors.append(
+                f"Missing expected filesystem changes ({len(missing)} file(s)):\n"
+                + "\n".join(f"  - {p}" for p in sorted(missing))
+            )
+
+        if errors:
+            raise AssertionError(
+                f"Filesystem expect_exactly failed with {len(errors)} error(s):\n"
+                + "\n".join(f"  {i+1}. {e}" for i, e in enumerate(errors))
+            )
+
+        return self
+
+    async def _validate_entry(
+        self, entry: FsFileDiffEntry, spec: Dict[str, Any], errors: List[str]
+    ) -> None:
+        path = spec["path"]
+
+        # Plain content checks (for text files)
+        if "content" in spec and spec["content"] is not ...:
+            if entry.content is None:
+                errors.append(f"'{path}': content not available (was content excluded from diff?)")
+            elif entry.content != spec["content"]:
+                errors.append(
+                    f"'{path}': content mismatch\n"
+                    f"    expected: {repr(spec['content'][:200])}\n"
+                    f"    actual:   {repr(entry.content[:200])}"
+                )
+
+        if "content_contains" in spec and spec["content_contains"] is not ...:
+            if entry.content is None:
+                errors.append(f"'{path}': content not available for content_contains check")
+            elif spec["content_contains"] not in entry.content:
+                errors.append(
+                    f"'{path}': content does not contain expected substring: "
+                    f"{repr(spec['content_contains'][:200])}"
+                )
+
+        # Document text checks (for docx, pptx, xlsx, etc. via /fs/doc/text)
+        if "doc_text" in spec or "doc_text_contains" in spec:
+            try:
+                doc_text = await self._resource.doc_text(path)
+            except Exception as e:
+                errors.append(f"'{path}': failed to extract doc text: {e}")
+                doc_text = None
+
+            if doc_text is not None:
+                if "doc_text" in spec and spec["doc_text"] is not ...:
+                    if doc_text != spec["doc_text"]:
+                        errors.append(
+                            f"'{path}': doc_text mismatch\n"
+                            f"    expected: {repr(spec['doc_text'][:200])}\n"
+                            f"    actual:   {repr(doc_text[:200])}"
+                        )
+
+                if "doc_text_contains" in spec and spec["doc_text_contains"] is not ...:
+                    if spec["doc_text_contains"] not in doc_text:
+                        errors.append(
+                            f"'{path}': doc text does not contain expected substring: "
+                            f"{repr(spec['doc_text_contains'][:200])}"
+                        )
+
+        if "file_type" in spec and spec["file_type"] is not ...:
+            if entry.file_type != spec["file_type"]:
+                errors.append(
+                    f"'{path}': file_type mismatch (expected {spec['file_type']!r}, got {entry.file_type!r})"
+                )
+
+        if "size" in spec and spec["size"] is not ...:
+            if entry.size != spec["size"]:
+                errors.append(
+                    f"'{path}': size mismatch (expected {spec['size']}, got {entry.size})"
+                )
+
+
+class AsyncFilesystemResource(Resource):
+    """Filesystem resource that operates via the /diff/fs and /fs/* endpoints."""
+
+    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
+        super().__init__(resource)
+        self.client = client
+
+    # ── Diff endpoints ────────────────────────────────────────────────
+
+    async def diff(
+        self,
+        include_content: bool = True,
+        max_content_size: int = 102400,
+        exclude_patterns: Optional[List[str]] = None,
+    ) -> AsyncFilesystemDiff:
+        """Get filesystem diff from the environment.
+
+        Args:
+            include_content: Whether to include file contents (default True)
+            max_content_size: Max file size to include content for (default 100KB)
+            exclude_patterns: Optional list of glob patterns to exclude
+
+        Returns:
+            AsyncFilesystemDiff with assertion helpers
+        """
+        request = FsDiffRequest(
+            include_content=include_content,
+            max_content_size=max_content_size,
+            exclude_patterns=exclude_patterns,
+        )
+        response = await self.client.request(
+            "POST",
+            "/diff/fs",
+            json=request.model_dump(exclude_none=True),
+        )
+        result = response.json()
+        fs_response = FsDiffResponse(**result)
+        if not fs_response.success:
+            raise RuntimeError(
+                f"Filesystem diff failed: {fs_response.error or fs_response.message}"
+            )
+        return AsyncFilesystemDiff(fs_response, self)
+
+    async def diff_simple(
+        self,
+        include_content: bool = True,
+        max_content_size: int = 102400,
+    ) -> AsyncFilesystemDiff:
+        """Get filesystem diff using the simple GET endpoint.
+
+        Args:
+            include_content: Whether to include file contents (default True)
+            max_content_size: Max file size to include content for (default 100KB)
+
+        Returns:
+            AsyncFilesystemDiff with assertion helpers
+        """
+        params = {
+            "include_content": include_content,
+            "max_content_size": max_content_size,
+        }
+        response = await self.client.request("GET", "/diff/fs", params=params)
+        result = response.json()
+        fs_response = FsDiffResponse(**result)
+        if not fs_response.success:
+            raise RuntimeError(
+                f"Filesystem diff failed: {fs_response.error or fs_response.message}"
+            )
+        return AsyncFilesystemDiff(fs_response, self)
+
+    # ── Single file endpoints ─────────────────────────────────────────
+
+    async def file(
+        self,
+        path: str,
+        include_content: bool = True,
+        max_content_size: int = 102400,
+    ) -> FileStateResponse:
+        """Get current state of a single file.
+
+        Args:
+            path: Absolute path to the file
+            include_content: Whether to include file content (default True)
+            max_content_size: Max file size to include content for (default 100KB)
+
+        Returns:
+            FileStateResponse with file metadata and optional content
+        """
+        request = FileStateRequest(
+            path=path,
+            include_content=include_content,
+            max_content_size=max_content_size,
+        )
+        response = await self.client.request(
+            "POST", "/fs/file", json=request.model_dump()
+        )
+        return FileStateResponse(**response.json())
+
+    async def file_text(self, path: str, max_content_size: int = 102400) -> str:
+        """Get file content as plain text.
+
+        Args:
+            path: Absolute path to the file
+            max_content_size: Max file size (default 100KB)
+
+        Returns:
+            File content as string
+        """
+        request = FileStateTextRequest(
+            path=path, max_content_size=max_content_size
+        )
+        response = await self.client.request(
+            "POST", "/fs/file/text", json=request.model_dump()
+        )
+        return response.text
+
+    # ── Document extraction endpoints ─────────────────────────────────
+
+    async def doc_text(self, path: str, max_size: int = 10485760) -> str:
+        """Extract plain text from a document file (docx, pptx, xlsx, pdf, etc.).
+
+        Args:
+            path: Absolute path to the document
+            max_size: Max document size (default 10MB)
+
+        Returns:
+            Extracted text content as string
+        """
+        request = DocTextRequest(path=path, max_size=max_size)
+        response = await self.client.request(
+            "POST", "/fs/doc/text", json=request.model_dump()
+        )
+        return response.text
+
+    async def doc_metadata(self, path: str) -> DocMetadataResponse:
+        """Extract metadata from a document file.
+
+        Args:
+            path: Absolute path to the document
+
+        Returns:
+            DocMetadataResponse with file_type and metadata dict
+        """
+        request = DocMetadataRequest(path=path)
+        response = await self.client.request(
+            "POST", "/fs/doc/metadata", json=request.model_dump()
+        )
+        return DocMetadataResponse(**response.json())
+
+    async def doc_structured(self, path: str) -> DocStructuredResponse:
+        """Extract structured content from a document file.
+
+        Args:
+            path: Absolute path to the document
+
+        Returns:
+            DocStructuredResponse with file_type and structured data dict
+        """
+        request = DocStructuredRequest(path=path)
+        response = await self.client.request(
+            "POST", "/fs/doc/structured", json=request.model_dump()
+        )
+        return DocStructuredResponse(**response.json())

{fleet_python-0.2.106 → fleet_python-0.2.108}/fleet/_async/tasks.py

@@ -346,9 +346,8 @@ def verifier_from_string(
                 return False
             return target in numbers
 
-        # Create a globals namespace with all required imports
-        exec_globals = globals().copy()
-        exec_globals.update({
+        # Create a local namespace for executing the code
+        local_namespace = {
             "TASK_SUCCESSFUL_SCORE": TASK_SUCCESSFUL_SCORE,
             "TASK_FAILED_SCORE": TASK_FAILED_SCORE,
             "IgnoreConfig": IgnoreConfig,
@@ -359,17 +358,10 @@ def verifier_from_string(
             "json": json,
             "re": re,
             "string": string,
-        })
-
-        # Create a local namespace for executing the code
-        local_namespace = {}
+        }
 
         # Execute the cleaned verifier code in the namespace
-        exec(cleaned_code, exec_globals, local_namespace)
-
-        # Merge local_namespace into exec_globals so helper functions are accessible
-        # from the main verifier function when it's called
-        exec_globals.update(local_namespace)
+        exec(cleaned_code, globals(), local_namespace)
 
         # Find the function that was defined (not imported)
         # Functions defined via exec have co_filename == '<string>'
@@ -456,12 +448,7 @@ async def load_tasks(
 
 
 async def update_task(
-    task_key: str,
-    prompt: Optional[str] = None,
-    verifier_code: Optional[str] = None,
-    metadata: Optional[Dict[str, Any]] = None,
-    writer_metadata: Optional[Dict[str, Any]] = None,
-    qa_metadata: Optional[Dict[str, Any]] = None,
+    task_key: str, prompt: Optional[str] = None, verifier_code: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None
 ):
     """Convenience function to update an existing task.
 
@@ -470,8 +457,6 @@ async def update_task(
         prompt: New prompt text for the task (optional)
         verifier_code: Python code for task verification (optional)
         metadata: Additional metadata for the task (optional)
-        writer_metadata: Metadata filled by task writer (optional)
-        qa_metadata: Metadata filled by QA reviewer (optional)
 
     Returns:
         TaskResponse containing the updated task details
@@ -480,18 +465,12 @@ async def update_task(
         response = await fleet.update_task("my-task", prompt="New prompt text")
         response = await fleet.update_task("my-task", verifier_code="def verify(env): return True")
         response = await fleet.update_task("my-task", metadata={"seed": 42, "story": "Updated story"})
-        response = await fleet.update_task("my-task", writer_metadata={"author": "john"})
     """
     from .global_client import get_client
 
     client = get_client()
     return await client.update_task(
-        task_key=task_key,
-        prompt=prompt,
-        verifier_code=verifier_code,
-        metadata=metadata,
-        writer_metadata=writer_metadata,
-        qa_metadata=qa_metadata,
+        task_key=task_key, prompt=prompt, verifier_code=verifier_code, metadata=metadata
     )