fleet-python 0.2.105__tar.gz → 0.2.107__tar.gz

{fleet_python-0.2.105/fleet_python.egg-info → fleet_python-0.2.107}/PKG-INFO

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

{fleet_python-0.2.105 → fleet_python-0.2.107}/examples/export_tasks.py

@@ -17,7 +17,8 @@ def main():
     parser.add_argument(
         "--task-keys",
         "-t",
-        help="Optional list of task keys to export (comma-separated)",
+        nargs="+",
+        help="Optional list of task keys to export (space-separated)",
         default=None,
     )
     parser.add_argument(
@@ -65,12 +66,10 @@ def main():
         print(f"Loading tasks from project: {args.project_key}")
         tasks = fleet.load_tasks(project_key=args.project_key)
     elif args.task_keys:
-        # Split comma-separated task keys and strip whitespace
-        task_keys_list = [key.strip() for key in args.task_keys.split(",")]
         print(
-            f"Loading {len(task_keys_list)} specific task(s): {', '.join(task_keys_list)}"
+            f"Loading {len(args.task_keys)} specific task(s): {', '.join(args.task_keys)}"
         )
-        tasks = fleet.load_tasks(keys=task_keys_list)
+        tasks = fleet.load_tasks(keys=args.task_keys)
     elif args.task_project_key:
         print(f"Loading tasks from task project: {args.task_project_key}")
         tasks = fleet.load_tasks(task_project_key=args.task_project_key)

{fleet_python-0.2.105 → fleet_python-0.2.107}/examples/import_tasks.py

@@ -1,9 +1,7 @@
 import asyncio
 import argparse
 import json
-import os
 import sys
-import tempfile
 from collections import defaultdict
 from typing import Dict, List, Tuple
 import fleet
@@ -185,6 +183,7 @@ async def run_verifier_sanity_check(
             print(f"  - {task_key}: {error_msg}")
         if len(errors) > 10:
             print(f"  ... and {len(errors) - 10} more")
+        print("\nFix the verifiers and try again.")
         return False, errors
     else:
         print("✓ All verifiers passed!")
@@ -238,7 +237,6 @@ async def main():
     task_count = len(tasks_data)
     task_keys = []
     missing_verifier = []
-    tasks_with_output_schema = []
     for task_data in tasks_data:
         task_key = task_data.get("key") or task_data.get("id")
         if task_key:
@@ -251,10 +249,6 @@ async def main():
         if not verifier_code:
             missing_verifier.append(task_key or "(no key)")
 
-        # Check for output_json_schema
-        if task_data.get("output_json_schema"):
-            tasks_with_output_schema.append(task_key or "(no key)")
-
     # Validate all tasks have verifier_func
     if missing_verifier:
         print(f"✗ Error: {len(missing_verifier)} task(s) missing verifier_func:")
@@ -297,64 +291,21 @@ async def main():
     print(f"✓ Loaded {len(tasks)} tasks")
 
     # Run sanity check (unless skipped)
-    already_confirmed = False  # Track if user already confirmed import
     if not args.skip_sanity_check:
         success, errors = await run_verifier_sanity_check(tasks, client)
+        if not success:
+            sys.exit(1)
 
-        # If only doing sanity check, exit here
+        # If only doing sanity check, exit successfully here
         if args.sanity_check_only:
-            if success:
-                print("\n✓ Sanity check complete! (--sanity-check-only)")
-                print("Tasks are ready to import.")
-                sys.exit(0)
-            else:
-                print("\n✗ Sanity check failed (--sanity-check-only)")
-                print("Fix the verifiers and try again.")
-                sys.exit(1)
-
-        # Handle partial failures
-        if not success:
-            # Filter out failed tasks
-            failed_keys = set(errors.keys())
-            passed_tasks = [t for t in tasks if t.key not in failed_keys]
-
-            print("\n" + "=" * 60)
-            print("SANITY CHECK RESULTS")
-            print("=" * 60)
-            print(f"Passed: {len(passed_tasks)}/{len(tasks)} tasks")
-            print(f"Failed: {len(failed_keys)}/{len(tasks)} tasks")
-
-            if len(passed_tasks) == 0:
-                print("\n✗ No tasks passed the sanity check.")
-                print("Fix the verifiers and try again.")
-                sys.exit(1)
-
-            # Prompt user to import only passed tasks
-            if not args.yes:
-                print("\nWould you like to import only the tasks that passed?")
-                response = input("Type 'YES' to import passed tasks only: ")
-                if response != "YES":
-                    print("Import cancelled.")
-                    sys.exit(0)
-                already_confirmed = True  # User already confirmed import
-            else:
-                print("\n⚠️  Auto-importing only tasks that passed (--yes flag)")
-
-            # Update tasks list and tasks_data to only include passed tasks
-            tasks = passed_tasks
-            passed_keys = {t.key for t in passed_tasks}
-            tasks_data = [td for td in tasks_data if td.get("key") in passed_keys]
-            # Also filter tasks_with_output_schema
-            tasks_with_output_schema = [
-                k for k in tasks_with_output_schema if k in passed_keys
-            ]
-
-            print(f"\nProceeding with {len(tasks)} tasks that passed sanity check")
+            print("\n✓ Sanity check complete! (--sanity-check-only)")
+            print("Tasks are ready to import.")
+            sys.exit(0)
     else:
         print("\n⚠️  Skipping sanity check (--skip-sanity-check)")
 
-    # Confirmation prompt (unless --yes flag is provided or already confirmed)
-    if not args.yes and not already_confirmed:
+    # Confirmation prompt (unless --yes flag is provided)
+    if not args.yes:
         print("\n" + "=" * 60)
         response = input("Type 'YES' to proceed with import: ")
         if response != "YES":
@@ -364,78 +315,10 @@ async def main():
     # Import tasks
     print("\nImporting tasks...")
     try:
-        # If tasks were filtered, write to a temporary file for import
-        if len(tasks_data) < task_count:
-            # Create temporary file with filtered tasks
-            with tempfile.NamedTemporaryFile(
-                mode="w", suffix=".json", delete=False, encoding="utf-8"
-            ) as temp_file:
-                json.dump(tasks_data, temp_file, indent=2, ensure_ascii=False)
-                temp_filename = temp_file.name
-
-            try:
-                results = await fleet.import_tasks_async(
-                    temp_filename, project_key=args.project_key
-                )
-            finally:
-                # Clean up temporary file
-                os.unlink(temp_filename)
-        else:
-            # Import from original file if no filtering occurred
-            results = await fleet.import_tasks_async(
-                args.json_file, project_key=args.project_key
-            )
-
-        # Print success summary
-        print("\n" + "=" * 60)
-        print("IMPORT COMPLETE")
-        print("=" * 60)
-        print(f"✓ Successfully imported {len(results)} task(s)")
-
-        if args.project_key:
-            print(f"✓ Associated with project: {args.project_key}")
-
-        print(f"✓ Team: {account.team_name}")
-
-        # Print HUGE warning if any tasks have output_json_schema
-        if tasks_with_output_schema:
-            print("\n")
-            print("!" * 80)
-            print("!" * 80)
-            print("!" * 80)
-            print(
-                "!!!                                                                          !!!"
-            )
-            print(
-                "!!!                          ⚠️  WARNING WARNING WARNING  ⚠️                          !!!"
-            )
-            print(
-                "!!!                                                                          !!!"
-            )
-            print(
-                f"!!!  {len(tasks_with_output_schema)} TASK(S) HAVE OUTPUT_JSON_SCHEMA THAT NEED MANUAL COPYING!  !!!"
-            )
-            print(
-                "!!!                                                                          !!!"
-            )
-            print(
-                "!!!  The output_json_schema field is NOT automatically imported!            !!!"
-            )
-            print(
-                "!!!  You MUST manually copy the output schemas to each task!                !!!"
-            )
-            print(
-                "!!!                                                                          !!!"
-            )
-            print("!" * 80)
-            print("!" * 80)
-            print("!" * 80)
-            print("\nTasks with output_json_schema:")
-            for i, key in enumerate(tasks_with_output_schema[:20], 1):
-                print(f"  {i}. {key}")
-            if len(tasks_with_output_schema) > 20:
-                print(f"  ... and {len(tasks_with_output_schema) - 20} more")
-            print("\n⚠️  REMEMBER TO MANUALLY COPY OUTPUT SCHEMAS! ⚠️\n")
+        results = await fleet.import_tasks_async(
+            args.json_file, project_key=args.project_key
+        )
+        print(f"\n✓ Successfully imported {len(results)} task(s)")
     except Exception as e:
         print(f"\n✗ Error importing tasks: {e}")
         sys.exit(1)

{fleet_python-0.2.105 → fleet_python-0.2.107}/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.107"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.105 → fleet_python-0.2.107}/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.107"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.105 → fleet_python-0.2.107}/fleet/_async/base.py

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

{fleet_python-0.2.105 → fleet_python-0.2.107}/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.
 
@@ -400,11 +405,6 @@ class AsyncEnv(EnvironmentBase):
             base_url = self.urls.api
         elif self.urls and self.urls.root:
             base_url = f"{self.urls.root.rstrip('/')}/raw"
-        elif self._manager_url_override and self._manager_url_override != "local://":
-            # URL mode: strip /api/v1/env suffix to get root URL
-            base_url = self._manager_url_override.rstrip('/')
-            if base_url.endswith('/api/v1/env'):
-                base_url = base_url[:-len('/api/v1/env')]
         else:
             raise ValueError("No API URL configured for this environment")
         return self.instance.api(name, base_url)
@@ -941,8 +941,6 @@ class AsyncFleet:
             verifier_sha=verifier_sha,  # Set verifier_sha
             verifier_runtime_version=verifier_runtime_version,  # Set verifier_runtime_version
             metadata=task_json.get("metadata", {}),  # Default empty metadata
-            writer_metadata=task_json.get("writer_metadata"),  # Writer metadata
-            qa_metadata=task_json.get("qa_metadata"),  # QA metadata
             output_json_schema=task_json.get("output_json_schema"),  # JSON schema for output
         )
         return task
@@ -1117,8 +1115,6 @@ class AsyncFleet:
                 verifier_sha=verifier_sha,  # Set verifier_sha
                 verifier_runtime_version=verifier_runtime_version,  # Set verifier_runtime_version
                 metadata=metadata,
-                writer_metadata=getattr(task_response, "writer_metadata", None),  # Writer metadata
-                qa_metadata=getattr(task_response, "qa_metadata", None),  # QA metadata
                 output_json_schema=getattr(task_response, "output_json_schema", None),  # Get output_json_schema if available
             )
             tasks.append(task)
@@ -1274,8 +1270,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.
 
@@ -1284,19 +1278,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.105 → fleet_python-0.2.107}/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.105 → fleet_python-0.2.107}/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):
@@ -199,8 +190,6 @@ class TaskResponse(BaseModel):
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
     verifier: Optional[VerifierData] = Field(None, title="Verifier")
     metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
-    writer_metadata: Optional[Dict[str, Any]] = Field(None, title="Writer Metadata")
-    qa_metadata: Optional[Dict[str, Any]] = Field(None, title="QA Metadata")
     output_json_schema: Optional[Dict[str, Any]] = Field(None, title="Output Json Schema")