fleet-python 0.2.54__tar.gz → 0.2.55__tar.gz

{fleet_python-0.2.54 → fleet_python-0.2.55}/PKG-INFO

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

fleet_python-0.2.55/examples/export_tasks.py

@@ -0,0 +1,76 @@
+import argparse
+import json
+import fleet
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Export tasks to a JSON file")
+    parser.add_argument(
+        "--project-key",
+        "-p",
+        help="Optional project key to filter tasks",
+        default=None,
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        help="Output JSON filename (defaults to {team_id}.json)",
+        default=None,
+    )
+
+    args = parser.parse_args()
+
+    # Get account info
+    account = fleet.env.account()
+    print(f"Exporting from team: {account.team_name}")
+
+    # Load tasks
+    if args.project_key:
+        print(f"Loading tasks from project: {args.project_key}")
+        tasks = fleet.load_tasks(project_key=args.project_key)
+    else:
+        print("Loading all tasks")
+        tasks = fleet.load_tasks()
+
+    print(f"\nFound {len(tasks)} task(s)")
+
+    # Validate that all tasks have verifier_func
+    print("Validating 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}.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 __name__ == "__main__":
+    main()

fleet_python-0.2.55/examples/import_tasks.py

@@ -0,0 +1,102 @@
+import asyncio
+import argparse
+import json
+import sys
+import fleet
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+async def main():
+    parser = argparse.ArgumentParser(description="Import tasks from a JSON file")
+    parser.add_argument("json_file", help="Path to the JSON file containing tasks")
+    parser.add_argument(
+        "--project-key",
+        "-p",
+        help="Optional project key to associate with the tasks",
+        default=None,
+    )
+    parser.add_argument(
+        "--yes",
+        "-y",
+        action="store_true",
+        help="Skip confirmation prompt and import automatically",
+    )
+
+    args = parser.parse_args()
+
+    # Load and parse the JSON file
+    try:
+        with open(args.json_file, "r", encoding="utf-8") as f:
+            tasks_data = json.load(f)
+    except FileNotFoundError:
+        print(f"Error: File '{args.json_file}' not found")
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in '{args.json_file}': {e}")
+        sys.exit(1)
+
+    # Extract task information and validate verifier_func
+    task_count = len(tasks_data)
+    task_keys = []
+    missing_verifier = []
+    for task_data in tasks_data:
+        task_key = task_data.get("key") or task_data.get("id")
+        if task_key:
+            task_keys.append(task_key)
+        else:
+            task_keys.append("(no key)")
+        
+        # Check for verifier_func
+        verifier_code = task_data.get("verifier_func") or task_data.get("verifier_code")
+        if not verifier_code:
+            missing_verifier.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:")
+        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")
+        print("\nAll tasks must have a verifier_func to be imported.")
+        sys.exit(1)
+
+    # Get account info
+    account = await fleet.env.account_async()
+
+    # Print summary
+    print(f"Importing to team: {account.team_name}")
+    print(f"\nFound {task_count} task(s) in '{args.json_file}':")
+    print("\nTask keys:")
+    for i, key in enumerate(task_keys, 1):
+        print(f"  {i}. {key}")
+
+    if args.project_key:
+        print(f"\nProject key: {args.project_key}")
+    else:
+        print("\nProject key: (none)")
+
+    # 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":
+            print("Import cancelled.")
+            sys.exit(0)
+
+    # 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)")
+    except Exception as e:
+        print(f"\n✗ Error importing tasks: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fleet_python-0.2.54 → fleet_python-0.2.55}/fleet/_async/client.py

@@ -372,6 +372,8 @@ class AsyncFleet:
             ),  # Use env_id or fallback to env_key
             created_at=task_json.get("created_at"),
             version=task_json.get("version"),
+            data_id=task_json.get("data_id"),
+            data_version=task_json.get("data_version"),
             env_variables=task_json.get("env_variables", {}),
             verifier_func=verifier_code,  # Set verifier code
             verifier=verifier,  # Use created verifier or None
@@ -386,6 +388,8 @@ class AsyncFleet:
         version: Optional[str] = None,
         team_id: Optional[str] = None,
         project_key: Optional[str] = None,
+        data_id: Optional[str] = None,
+        data_version: Optional[str] = None,
     ) -> List[Task]:
         """Load tasks for the authenticated team, with optional filtering.
 
@@ -394,6 +398,9 @@ class AsyncFleet:
             keys: Optional list of task keys to filter by
             version: Optional version to filter tasks by (client-side filter)
             team_id: Optional team_id to filter by (admin only)
+            project_key: Optional project key to filter tasks by
+            data_id: Optional data identifier to filter tasks by
+            data_version: Optional data version to filter tasks by
 
         Returns:
             List[Task] containing Task objects
@@ -407,6 +414,10 @@ class AsyncFleet:
             params["team_id"] = team_id
         if project_key is not None:
             params["project_key"] = project_key
+        if data_id is not None:
+            params["data_id"] = data_id
+        if data_version is not None:
+            params["data_version"] = data_version
 
         response = await self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())
@@ -511,6 +522,8 @@ class AsyncFleet:
                 env_id=task_response.environment_id,  # Map environment_id -> env_id
                 created_at=task_response.created_at,
                 version=task_response.version,
+                data_id=getattr(task_response, "data_id", None),  # Get data_id if available
+                data_version=getattr(task_response, "data_version", None),  # Get data_version if available
                 env_variables=task_response.env_variables or {},
                 verifier_func=verifier_func,  # Set verifier code
                 verifier=verifier,  # Use created verifier or None
@@ -521,6 +534,14 @@ class AsyncFleet:
         # Apply client-side filtering for version if specified
         if version is not None:
             tasks = [task for task in tasks if task.version == version]
+        
+        # Apply client-side filtering for data_id if specified
+        if data_id is not None:
+            tasks = [task for task in tasks if task.data_id == data_id]
+        
+        # Apply client-side filtering for data_version if specified
+        if data_version is not None:
+            tasks = [task for task in tasks if task.data_version == data_version]
 
         return tasks
 

{fleet_python-0.2.54 → fleet_python-0.2.55}/fleet/_async/tasks.py

@@ -25,6 +25,8 @@ class Task(BaseModel):
     )
     created_at: Optional[datetime] = Field(None, description="Task creation timestamp")
     version: Optional[str] = Field(None, description="Task version")
+    data_id: Optional[str] = Field(None, description="Data identifier")
+    data_version: Optional[str] = Field(None, description="Data version")
     verifier_func: Optional[str] = Field(None, description="Verifier function code")
     verifier: Optional[Any] = Field(
         None,
@@ -58,6 +60,15 @@ class Task(BaseModel):
             return f"{self.env_id}:{self.version}"
         return self.env_id
 
+    @property
+    def data_key(self) -> Optional[str]:
+        """Get the data key combining data_id and data_version."""
+        if self.data_id and self.data_version:
+            return f"{self.data_id}:{self.data_version}"
+        elif self.data_id:
+            return self.data_id
+        return None
+
     class Config:
         """Pydantic model configuration."""
 
@@ -282,6 +293,8 @@ async def load_tasks(
     version: Optional[str] = None,
     team_id: Optional[str] = None,
     project_key: Optional[str] = None,
+    data_id: Optional[str] = None,
+    data_version: Optional[str] = None,
 ) -> List[Task]:
     """Convenience function to load tasks with optional filtering.
 
@@ -290,11 +303,15 @@ async def load_tasks(
         keys: Optional list of task keys to filter by
         version: Optional version to filter tasks by
         team_id: Optional team_id to filter by (admin only)
+        project_key: Optional project key to filter tasks by
+        data_id: Optional data identifier to filter tasks by
+        data_version: Optional data version to filter tasks by
 
     Examples:
         tasks = await fleet.load_tasks(env_key="fira")
         tasks = await fleet.load_tasks(keys=["task1", "task2"])
         tasks = await fleet.load_tasks(env_key="fira", version="v1.0")
+        tasks = await fleet.load_tasks(data_id="my-data", data_version="v1.0")
     """
     # Use the global client by default so users can pre-configure it once
     from .global_client import get_client
@@ -306,6 +323,8 @@ async def load_tasks(
         version=version,
         team_id=team_id,
         project_key=project_key,
+        data_id=data_id,
+        data_version=data_version,
     )
 
 

{fleet_python-0.2.54 → fleet_python-0.2.55}/fleet/client.py

@@ -370,6 +370,8 @@ class Fleet:
             ),  # Use env_id or fallback to env_key
             created_at=task_json.get("created_at"),
             version=task_json.get("version"),
+            data_id=task_json.get("data_id"),
+            data_version=task_json.get("data_version"),
             env_variables=task_json.get("env_variables", {}),
             verifier_func=verifier_code,  # Set verifier code
             verifier=verifier,  # Use created verifier or None
@@ -384,6 +386,8 @@ class Fleet:
         version: Optional[str] = None,
         team_id: Optional[str] = None,
         project_key: Optional[str] = None,
+        data_id: Optional[str] = None,
+        data_version: Optional[str] = None,
     ) -> List[Task]:
         """Load tasks for the authenticated team, with optional filtering.
 
@@ -392,6 +396,9 @@ class Fleet:
             keys: Optional list of task keys to filter by
             version: Optional version to filter tasks by (client-side filter)
             team_id: Optional team_id to filter by (admin only)
+            project_key: Optional project key to filter tasks by
+            data_id: Optional data identifier to filter tasks by
+            data_version: Optional data version to filter tasks by
 
         Returns:
             List[Task] containing Task objects
@@ -405,6 +412,10 @@ class Fleet:
             params["team_id"] = team_id
         if project_key is not None:
             params["project_key"] = project_key
+        if data_id is not None:
+            params["data_id"] = data_id
+        if data_version is not None:
+            params["data_version"] = data_version
 
         response = self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())
@@ -517,6 +528,8 @@ class Fleet:
                 env_id=task_response.environment_id,  # Map environment_id -> env_id
                 created_at=task_response.created_at,
                 version=task_response.version,
+                data_id=getattr(task_response, "data_id", None),  # Get data_id if available
+                data_version=getattr(task_response, "data_version", None),  # Get data_version if available
                 env_variables=task_response.env_variables or {},
                 verifier_func=verifier_func,  # Set verifier code
                 verifier=verifier,  # Use created verifier or None
@@ -527,6 +540,14 @@ class Fleet:
         # Apply client-side filtering for version if specified
         if version is not None:
             tasks = [task for task in tasks if task.version == version]
+        
+        # Apply client-side filtering for data_id if specified
+        if data_id is not None:
+            tasks = [task for task in tasks if task.data_id == data_id]
+        
+        # Apply client-side filtering for data_version if specified
+        if data_version is not None:
+            tasks = [task for task in tasks if task.data_version == data_version]
 
         return tasks
 

{fleet_python-0.2.54 → fleet_python-0.2.55}/fleet/tasks.py

@@ -26,6 +26,8 @@ class Task(BaseModel):
     )
     created_at: Optional[datetime] = Field(None, description="Task creation timestamp")
     version: Optional[str] = Field(None, description="Task version")
+    data_id: Optional[str] = Field(None, description="Data identifier")
+    data_version: Optional[str] = Field(None, description="Data version")
     verifier_func: Optional[str] = Field(None, description="Verifier function code")
     verifier: Optional[Any] = Field(
         None,
@@ -59,6 +61,15 @@ class Task(BaseModel):
             return f"{self.env_id}:{self.version}"
         return self.env_id
 
+    @property
+    def data_key(self) -> Optional[str]:
+        """Get the data key combining data_id and data_version."""
+        if self.data_id and self.data_version:
+            return f"{self.data_id}:{self.data_version}"
+        elif self.data_id:
+            return self.data_id
+        return None
+
     class Config:
         """Pydantic model configuration."""
 
@@ -285,6 +296,8 @@ def load_tasks(
     version: Optional[str] = None,
     team_id: Optional[str] = None,
     project_key: Optional[str] = None,
+    data_id: Optional[str] = None,
+    data_version: Optional[str] = None,
 ) -> List[Task]:
     """Convenience function to load tasks with optional filtering.
 
@@ -293,11 +306,15 @@ def load_tasks(
         keys: Optional list of task keys to filter by
         version: Optional version to filter tasks by
         team_id: Optional team_id to filter by (admin only)
+        project_key: Optional project key to filter tasks by
+        data_id: Optional data identifier to filter tasks by
+        data_version: Optional data version to filter tasks by
 
     Examples:
-        tasks = await fleet.load_tasks(env_key="fira")
-        tasks = await fleet.load_tasks(keys=["task1", "task2"])
-        tasks = await fleet.load_tasks(env_key="fira", version="v1.0")
+        tasks = fleet.load_tasks(env_key="fira")
+        tasks = fleet.load_tasks(keys=["task1", "task2"])
+        tasks = fleet.load_tasks(env_key="fira", version="v1.0")
+        tasks = fleet.load_tasks(data_id="my-data", data_version="v1.0")
     """
     # Use the global client by default so users can pre-configure it once
     from .global_client import get_client
@@ -309,6 +326,8 @@ def load_tasks(
         version=version,
         team_id=team_id,
         project_key=project_key,
+        data_id=data_id,
+        data_version=data_version,
     )
 
 

{fleet_python-0.2.54 → fleet_python-0.2.55}/fleet_python.egg-info/PKG-INFO

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

{fleet_python-0.2.54 → fleet_python-0.2.55}/fleet_python.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ examples/example_sync.py
 examples/example_task.py
 examples/example_tasks.py
 examples/example_verifier.py
+examples/export_tasks.py
 examples/gemini_example.py
 examples/import_tasks.py
 examples/json_tasks_example.py

{fleet_python-0.2.54 → fleet_python-0.2.55}/pyproject.toml

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

fleet_python-0.2.54/examples/import_tasks.py

@@ -1,16 +0,0 @@
-import asyncio
-import fleet
-from dotenv import load_dotenv
-
-load_dotenv()
-
-
-async def main():
-    print(f"Importing tasks... {(await fleet.env.account_async()).team_name}")
-    await fleet._async.import_tasks(
-        "6bb6c6b6-36a8-4407-ba66-6908e42069c8.json", project_key="amazon"
-    )
-
-
-if __name__ == "__main__":
-    asyncio.run(main())