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

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

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

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

@@ -17,8 +17,7 @@ def main():
     parser.add_argument(
         "--task-keys",
         "-t",
-        nargs="+",
-        help="Optional list of task keys to export (space-separated)",
+        help="Optional list of task keys to export (comma-separated)",
         default=None,
     )
     parser.add_argument(
@@ -66,10 +65,12 @@ 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(args.task_keys)} specific task(s): {', '.join(args.task_keys)}"
+            f"Loading {len(task_keys_list)} specific task(s): {', '.join(task_keys_list)}"
         )
-        tasks = fleet.load_tasks(keys=args.task_keys)
+        tasks = fleet.load_tasks(keys=task_keys_list)
     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.109/examples/export_tasks_filtered.py

@@ -0,0 +1,245 @@
+"""
+Export tasks to JSON, excluding tasks from targets marked as 'unused'.
+
+This script filters out tasks whose task_project_target has status='unused',
+ensuring that broken/invalid targets don't pollute exports.
+
+Usage:
+    python export_tasks_filtered.py --task-project-key my-project
+    python export_tasks_filtered.py --project-key my-project --output tasks.json
+    python export_tasks_filtered.py --env-key my-env
+"""
+
+import argparse
+import json
+import os
+from typing import List, Set
+
+import fleet
+from dotenv import load_dotenv
+from supabase import create_client, Client
+
+load_dotenv()
+
+
+def get_unused_target_ids(supabase: Client, team_id: str) -> Set[str]:
+    """Fetch all target IDs that have status='unused' for the given team."""
+    # Get all task_projects for this team first
+    projects_response = (
+        supabase.table("task_projects")
+        .select("id")
+        .eq("team_id", team_id)
+        .execute()
+    )
+    
+    if not projects_response.data:
+        return set()
+    
+    project_ids = [p["id"] for p in projects_response.data]
+    
+    # Get all targets with status='unused' for these projects
+    targets_response = (
+        supabase.table("task_project_targets")
+        .select("id")
+        .in_("project_id", project_ids)
+        .eq("status", "unused")
+        .execute()
+    )
+    
+    if not targets_response.data:
+        return set()
+    
+    return {t["id"] for t in targets_response.data}
+
+
+def get_task_target_mapping(supabase: Client, task_keys: List[str], team_id: str) -> dict:
+    """Fetch task_project_target_id for each task key."""
+    if not task_keys:
+        return {}
+    
+    # Batch the queries to avoid hitting limits
+    BATCH_SIZE = 100
+    mapping = {}
+    
+    for i in range(0, len(task_keys), BATCH_SIZE):
+        batch_keys = task_keys[i:i + BATCH_SIZE]
+        response = (
+            supabase.table("eval_tasks")
+            .select("key, task_project_target_id")
+            .in_("key", batch_keys)
+            .eq("team_id", team_id)
+            .execute()
+        )
+        
+        for row in response.data or []:
+            mapping[row["key"]] = row.get("task_project_target_id")
+    
+    return mapping
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Export tasks to JSON, excluding tasks from 'unused' targets"
+    )
+    parser.add_argument(
+        "--project-key",
+        "-p",
+        help="Optional project key to filter tasks",
+        default=None,
+    )
+    parser.add_argument(
+        "--task-keys",
+        "-t",
+        nargs="+",
+        help="Optional list of task keys to export (space-separated)",
+        default=None,
+    )
+    parser.add_argument(
+        "--task-project-key",
+        "-tpk",
+        help="Optional task project key to filter tasks",
+        default=None,
+    )
+    parser.add_argument(
+        "--env-key",
+        "-e",
+        help="Optional environment key to filter tasks",
+        default=None,
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        help="Output JSON filename (defaults to {team_id}_filtered.json)",
+        default=None,
+    )
+    parser.add_argument(
+        "--include-unused",
+        action="store_true",
+        help="Include tasks from 'unused' targets (disables filtering)",
+    )
+
+    args = parser.parse_args()
+
+    # Validate that only one filter is specified
+    filters_specified = sum(
+        [
+            args.project_key is not None,
+            args.task_keys is not None,
+            args.task_project_key is not None,
+            args.env_key is not None,
+        ]
+    )
+
+    if filters_specified > 1:
+        parser.error(
+            "Cannot specify multiple filters. Use only one of --project-key, --task-keys, --task-project-key, or --env-key."
+        )
+
+    # Get account info
+    account = fleet.env.account()
+    print(f"Exporting from team: {account.team_name}")
+
+    # Initialize Supabase client for filtering
+    supabase_url = os.getenv("SUPABASE_URL") or os.getenv("NEXT_PUBLIC_SUPABASE_URL")
+    supabase_key = os.getenv("SUPABASE_SERVICE_ROLE_KEY") or os.getenv("SUPABASE_KEY")
+    
+    if not supabase_url or not supabase_key:
+        print("⚠ Warning: SUPABASE_URL/SUPABASE_KEY not set - cannot filter by target status")
+        print("  Falling back to unfiltered export")
+        supabase = None
+    else:
+        supabase = create_client(supabase_url, supabase_key)
+
+    # Load tasks
+    if args.project_key:
+        print(f"Loading tasks from project: {args.project_key}")
+        tasks = fleet.load_tasks(project_key=args.project_key)
+    elif args.task_keys:
+        print(f"Loading {len(args.task_keys)} specific task(s): {', '.join(args.task_keys)}")
+        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)
+    elif args.env_key:
+        print(f"Loading tasks from environment: {args.env_key}")
+        tasks = fleet.load_tasks(env_key=args.env_key)
+    else:
+        print("Loading all tasks")
+        tasks = fleet.load_tasks()
+
+    print(f"\nFound {len(tasks)} task(s) before filtering")
+
+    # Filter out tasks from unused targets
+    filtered_tasks = tasks
+    excluded_count = 0
+    
+    if supabase and not args.include_unused:
+        print("\nFiltering out tasks from 'unused' targets...")
+        
+        # Get unused target IDs
+        unused_target_ids = get_unused_target_ids(supabase, account.team_id)
+        
+        if unused_target_ids:
+            print(f"  Found {len(unused_target_ids)} unused target(s)")
+            
+            # Get task -> target mapping
+            task_keys = [t.key for t in tasks]
+            task_target_map = get_task_target_mapping(supabase, task_keys, account.team_id)
+            
+            # Filter tasks
+            filtered_tasks = []
+            for task in tasks:
+                target_id = task_target_map.get(task.key)
+                if target_id in unused_target_ids:
+                    excluded_count += 1
+                else:
+                    filtered_tasks.append(task)
+            
+            print(f"  Excluded {excluded_count} task(s) from unused targets")
+        else:
+            print("  No unused targets found - all tasks included")
+    
+    tasks = filtered_tasks
+    print(f"\n{len(tasks)} task(s) after filtering")
+
+    # Validate that all tasks have verifier_func
+    print("\nValidating tasks have verifier_func...")
+    missing_verifier = []
+    for task in tasks:
+        if not task.verifier_func:
+            missing_verifier.append(task.key)
+
+    if missing_verifier:
+        print(f"\n✗ Error: {len(missing_verifier)} task(s) missing verifier_func:")
+        for key in missing_verifier[:10]:  # Show first 10
+            print(f"  - {key}")
+        if len(missing_verifier) > 10:
+            print(f"  ... and {len(missing_verifier) - 10} more")
+        raise ValueError(
+            "All tasks must have a verifier_func. Cannot export tasks without verifiers."
+        )
+
+    print("✓ All tasks have verifier_func")
+
+    # Determine output filename
+    output_file = args.output or f"{account.team_id}_filtered.json"
+
+    # Export to JSON
+    print(f"\nExporting to: {output_file}")
+    with open(output_file, "w", encoding="utf-8") as f:
+        json.dump(
+            [task.model_dump() for task in tasks],
+            f,
+            indent=2,
+            ensure_ascii=False,
+        )
+
+    print(f"✓ Successfully exported {len(tasks)} task(s) to {output_file}")
+    if excluded_count > 0:
+        print(f"  ({excluded_count} task(s) excluded from unused targets)")
+
+
+if __name__ == "__main__":
+    main()
+
+

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

@@ -1,7 +1,9 @@
 import asyncio
 import argparse
 import json
+import os
 import sys
+import tempfile
 from collections import defaultdict
 from typing import Dict, List, Tuple
 import fleet
@@ -183,7 +185,6 @@ 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!")
@@ -237,6 +238,7 @@ 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:
@@ -249,6 +251,10 @@ 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:")
@@ -291,21 +297,64 @@ 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 successfully here
+        # If only doing sanity check, exit here
         if args.sanity_check_only:
-            print("\n✓ Sanity check complete! (--sanity-check-only)")
-            print("Tasks are ready to import.")
-            sys.exit(0)
+            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")
     else:
         print("\n⚠️  Skipping sanity check (--skip-sanity-check)")
 
-    # Confirmation prompt (unless --yes flag is provided)
-    if not args.yes:
+    # Confirmation prompt (unless --yes flag is provided or already confirmed)
+    if not args.yes and not already_confirmed:
         print("\n" + "=" * 60)
         response = input("Type 'YES' to proceed with import: ")
         if response != "YES":
@@ -315,10 +364,78 @@ async def main():
     # Import tasks
     print("\nImporting tasks...")
     try:
-        results = await fleet.import_tasks_async(
-            args.json_file, project_key=args.project_key
-        )
-        print(f"\n✓ Successfully imported {len(results)} task(s)")
+        # 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")
     except Exception as e:
         print(f"\n✗ Error importing tasks: {e}")
         sys.exit(1)

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

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

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

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

{fleet_python-0.2.107 → fleet_python-0.2.109}/fleet/_async/client.py

@@ -405,6 +405,11 @@ 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)

{fleet_python-0.2.107 → fleet_python-0.2.109}/fleet/_async/resources/sqlite.py

@@ -99,10 +99,11 @@ class AsyncDatabaseSnapshot:
         self,
         other: "AsyncDatabaseSnapshot",
         ignore_config: Optional[IgnoreConfig] = None,
+        use_structured_diff: bool = False,
     ) -> "AsyncSnapshotDiff":
         """Compare this snapshot with another."""
         # No need to fetch all data upfront - diff will fetch on demand
-        return AsyncSnapshotDiff(self, other, ignore_config)
+        return AsyncSnapshotDiff(self, other, ignore_config, use_structured_diff=use_structured_diff)
 
 
 class AsyncSnapshotQueryBuilder:
@@ -275,10 +276,12 @@ class AsyncSnapshotDiff:
         before: AsyncDatabaseSnapshot,
         after: AsyncDatabaseSnapshot,
         ignore_config: Optional[IgnoreConfig] = None,
+        use_structured_diff: bool = False,
     ):
         self.before = before
         self.after = after
         self.ignore_config = ignore_config or IgnoreConfig()
+        self.use_structured_diff = use_structured_diff
         self._cached: Optional[Dict[str, Any]] = None
         self._targeted_mode = False  # Flag to use targeted queries
 
@@ -1766,8 +1769,7 @@ class AsyncSnapshotDiff:
             return await self._expect_no_changes()
 
         resource = self.after.resource
-        # Disabled: structured diff endpoint not yet available
-        if False and resource.client is not None and resource._mode == "http":
+        if self.use_structured_diff and resource.client is not None and resource._mode == "http":
             api_diff = None
             try:
                 payload = {}
@@ -2478,12 +2480,15 @@ class AsyncSQLiteResource(Resource):
         self,
         other: "AsyncSQLiteResource",
         ignore_config: Optional[IgnoreConfig] = None,
+        use_structured_diff: bool = False,
     ) -> AsyncSnapshotDiff:
         """Compare this database with another AsyncSQLiteResource.
 
         Args:
             other: Another AsyncSQLiteResource to compare against
             ignore_config: Optional configuration for ignoring specific tables/fields
+            use_structured_diff: If True, use server-side structured diff API in expect_only_v2.
+                Defaults to False (local diff only).
 
         Returns:
             AsyncSnapshotDiff: Object containing the differences between the two databases
@@ -2497,4 +2502,4 @@ class AsyncSQLiteResource(Resource):
         )
 
         # Return the diff between the snapshots
-        return await before_snapshot.diff(after_snapshot, ignore_config)
+        return await before_snapshot.diff(after_snapshot, ignore_config, use_structured_diff=use_structured_diff)

{fleet_python-0.2.107 → fleet_python-0.2.109}/fleet/base.py

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

{fleet_python-0.2.107 → fleet_python-0.2.109}/fleet/client.py

@@ -417,6 +417,11 @@ class SyncEnv(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)

{fleet_python-0.2.107 → fleet_python-0.2.109}/fleet/resources/sqlite.py

@@ -98,10 +98,11 @@ class SyncDatabaseSnapshot:
         self,
         other: "SyncDatabaseSnapshot",
         ignore_config: Optional[IgnoreConfig] = None,
+        use_structured_diff: bool = False,
     ) -> "SyncSnapshotDiff":
         """Compare this snapshot with another."""
         # No need to fetch all data upfront - diff will fetch on demand
-        return SyncSnapshotDiff(self, other, ignore_config)
+        return SyncSnapshotDiff(self, other, ignore_config, use_structured_diff=use_structured_diff)
 
 
 class SyncSnapshotQueryBuilder:
@@ -274,10 +275,12 @@ class SyncSnapshotDiff:
         before: SyncDatabaseSnapshot,
         after: SyncDatabaseSnapshot,
         ignore_config: Optional[IgnoreConfig] = None,
+        use_structured_diff: bool = False,
     ):
         self.before = before
         self.after = after
         self.ignore_config = ignore_config or IgnoreConfig()
+        self.use_structured_diff = use_structured_diff
         self._cached: Optional[Dict[str, Any]] = None
         self._targeted_mode = False  # Flag to use targeted queries
 
@@ -1814,8 +1817,7 @@ class SyncSnapshotDiff:
             return self._expect_no_changes()
 
         resource = self.after.resource
-        # Disabled: structured diff endpoint not yet available
-        if False and resource.client is not None and resource._mode == "http":
+        if self.use_structured_diff and resource.client is not None and resource._mode == "http":
             api_diff = None
             try:
                 payload = {}
@@ -2516,19 +2518,22 @@ class SQLiteResource(Resource):
         self,
         other: "SQLiteResource",
         ignore_config: Optional[IgnoreConfig] = None,
+        use_structured_diff: bool = False,
     ) -> SyncSnapshotDiff:
-        """Compare this database with another AsyncSQLiteResource.
+        """Compare this database with another SQLiteResource.
 
         Args:
-            other: Another AsyncSQLiteResource to compare against
+            other: Another SQLiteResource to compare against
             ignore_config: Optional configuration for ignoring specific tables/fields
+            use_structured_diff: If True, use server-side structured diff API in expect_only_v2.
+                Defaults to False (local diff only).
 
         Returns:
-            AsyncSnapshotDiff: Object containing the differences between the two databases
+            SyncSnapshotDiff: Object containing the differences between the two databases
         """
         # Create snapshots of both databases
         before_snapshot = self.snapshot(name=f"before_{datetime.utcnow().isoformat()}")
         after_snapshot = other.snapshot(name=f"after_{datetime.utcnow().isoformat()}")
 
         # Return the diff between the snapshots
-        return before_snapshot.diff(after_snapshot, ignore_config)
+        return before_snapshot.diff(after_snapshot, ignore_config, use_structured_diff=use_structured_diff)

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

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

{fleet_python-0.2.107 → fleet_python-0.2.109}/fleet_python.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ examples/example_task.py
 examples/example_tasks.py
 examples/example_verifier.py
 examples/export_tasks.py
+examples/export_tasks_filtered.py
 examples/fetch_tasks.py
 examples/gemini_example.py
 examples/import_tasks.py

{fleet_python-0.2.107 → fleet_python-0.2.109}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "fleet-python"
 
-version = "0.2.107"
+version = "0.2.109"
 description = "Python SDK for Fleet environments"
 authors = [
     {name = "Fleet AI", email = "nic@fleet.so"},