fleet-python 0.2.53__py3-none-any.whl → 0.2.55__py3-none-any.whl

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()

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/__init__.py

@@ -51,10 +51,17 @@ from ._async.tasks import (
     Task,
     load_tasks as load_tasks_async,
     load_tasks_from_file as load_tasks_from_file_async,
+    import_task as import_task_async,
+    import_tasks as import_tasks_async,
 )
 
-# Import sync load_tasks function
-from .tasks import load_tasks, load_tasks_from_file
+# Import sync task functions
+from .tasks import (
+    load_tasks,
+    load_tasks_from_file,
+    import_task,
+    import_tasks,
+)
 
 # Import shared types
 from .types import VerifierFunction
@@ -104,6 +111,12 @@ __all__ = [
     # Module-level functions (async is default)
     "load_tasks",
     "load_tasks_async",
+    "load_tasks_from_file",
+    "load_tasks_from_file_async",
+    "import_task",
+    "import_task_async",
+    "import_tasks",
+    "import_tasks_async",
     # Version
     "__version__",
 ]

fleet/_async/__init__.py

@@ -86,6 +86,7 @@ __all__ = [
     "load_task_from_string",
     "load_task_from_json",
     "export_tasks",
+    "import_task",
     "import_tasks",
     "account",
     # Version
@@ -193,6 +194,21 @@ async def export_tasks(
     return await _async_global_client.get_client().export_tasks(env_key, filename)
 
 
+async def import_task(task, project_key: Optional[str] = None):
+    """Import a single task.
+
+    Args:
+        task: Task object to import
+        project_key: Optional project key to associate with the task
+
+    Example:
+        task = fleet.Task(key="my-task", prompt="Do something", env_id="my-env")
+        await fleet.import_task(task)
+        await fleet.import_task(task, project_key="my-project")
+    """
+    return await _async_global_client.get_client().import_single_task(task, project_key)
+
+
 async def import_tasks(filename: str, project_key: Optional[str] = None):
     """Import tasks from a JSON file.
 

fleet/_async/client.py

@@ -328,7 +328,9 @@ class AsyncFleet:
         task_json = json.loads(task_string)
         return await self.load_task_from_json(task_json)
 
-    async def load_task_from_json(self, task_json: Dict) -> Task:
+    async def load_task_from_json(
+        self, task_json: Dict, raise_on_verifier_error: bool = False
+    ) -> Task:
         verifier = None
         verifier_code = task_json.get("verifier_func") or task_json.get("verifier_code")
 
@@ -356,9 +358,11 @@ class AsyncFleet:
                     verifier_sha=task_json.get("verifier_sha", ""),
                 )
         except Exception as e:
-            logger.warning(
-                f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
-            )
+            error_msg = f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
+            if raise_on_verifier_error:
+                raise ValueError(error_msg) from e
+            else:
+                logger.warning(error_msg)
 
         task = Task(
             key=task_json.get("key", task_json.get("id")),
@@ -368,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
@@ -382,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.
 
@@ -390,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
@@ -403,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())
@@ -507,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
@@ -517,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
 
@@ -571,6 +596,13 @@ class AsyncFleet:
             Response from the API, or None if the import failed
         """
         try:
+            # Validate that verifier_func exists
+            if not task.verifier_func:
+                raise ValueError(
+                    f"Task {task.key} is missing verifier_func. "
+                    "All tasks must have a verifier_func to be imported."
+                )
+
             params = {}
             if project_key:
                 params["project_key"] = project_key
@@ -591,14 +623,33 @@ class AsyncFleet:
 
         Returns:
             List[Task] containing imported Task objects
+
+        Raises:
+            ValueError: If any task is missing verifier_func or has invalid verifier code
         """
         with open(filename, "r", encoding="utf-8") as f:
             tasks_data = json.load(f)
 
-        # Create tasks from the loaded data
+        # Create tasks from the loaded data using load_task_from_json
+        # This will validate and create verifiers properly
         tasks = []
         for task_data in tasks_data:
-            task = Task(**task_data)
+            # Validate that verifier_func exists
+            verifier_code = task_data.get("verifier_func") or task_data.get(
+                "verifier_code"
+            )
+            if not verifier_code:
+                task_key = task_data.get("key", task_data.get("id", "unknown"))
+                raise ValueError(
+                    f"Task {task_key} is missing verifier_func. "
+                    "All tasks must have a verifier_func to be imported."
+                )
+
+            # Use load_task_from_json to properly create and validate the task
+            # Pass raise_on_verifier_error=True to fail fast on invalid verifier code
+            task = await self.load_task_from_json(
+                task_data, raise_on_verifier_error=True
+            )
             tasks.append(task)
 
         # Use semaphore to limit concurrency to 20

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,
     )
 
 
@@ -332,3 +351,44 @@ async def update_task(
     return await client.update_task(
         task_key=task_key, prompt=prompt, verifier_code=verifier_code
     )
+
+
+async def import_task(task: Task, project_key: Optional[str] = None):
+    """Convenience function to import a single task.
+
+    Args:
+        task: Task object to import
+        project_key: Optional project key to associate with the task
+
+    Returns:
+        Response from the API, or None if the import failed
+
+    Examples:
+        task = fleet.Task(key="my-task", prompt="Do something", env_id="my-env")
+        response = await fleet.import_task(task)
+        response = await fleet.import_task(task, project_key="my-project")
+    """
+    from .global_client import get_client
+
+    client = get_client()
+    return await client.import_single_task(task, project_key=project_key)
+
+
+async def import_tasks(filename: str, project_key: Optional[str] = None):
+    """Convenience function to import tasks from a JSON file.
+
+    Args:
+        filename: Path to the JSON file of Task objects to import
+        project_key: Optional project key to associate with the tasks
+
+    Returns:
+        List of responses from the API for successfully imported tasks
+
+    Examples:
+        responses = await fleet.import_tasks("tasks.json")
+        responses = await fleet.import_tasks("tasks.json", project_key="my-project")
+    """
+    from .global_client import get_client
+
+    client = get_client()
+    return await client.import_tasks(filename, project_key=project_key)

fleet/client.py

@@ -326,7 +326,9 @@ class Fleet:
         task_json = json.loads(task_string)
         return self.load_task_from_json(task_json)
 
-    def load_task_from_json(self, task_json: Dict) -> Task:
+    def load_task_from_json(
+        self, task_json: Dict, raise_on_verifier_error: bool = False
+    ) -> Task:
         verifier = None
         verifier_code = task_json.get("verifier_func") or task_json.get("verifier_code")
 
@@ -354,9 +356,11 @@ class Fleet:
                     verifier_sha=task_json.get("verifier_sha", ""),
                 )
         except Exception as e:
-            logger.warning(
-                f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
-            )
+            error_msg = f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
+            if raise_on_verifier_error:
+                raise ValueError(error_msg) from e
+            else:
+                logger.warning(error_msg)
 
         task = Task(
             key=task_json.get("key", task_json.get("id")),
@@ -366,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
@@ -380,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.
 
@@ -388,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
@@ -401,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())
@@ -513,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
@@ -523,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
 
@@ -577,10 +602,19 @@ class Fleet:
             Response from the API, or None if the import failed
         """
         try:
+            # Validate that verifier_func exists
+            if not task.verifier_func:
+                raise ValueError(
+                    f"Task {task.key} is missing verifier_func. "
+                    "All tasks must have a verifier_func to be imported."
+                )
+
             params = {}
             if project_key:
                 params["project_key"] = project_key
-            response = self.client.request("POST", "/v1/tasks", json=task.model_dump(), params=params)
+            response = self.client.request(
+                "POST", "/v1/tasks", json=task.model_dump(), params=params
+            )
             return response
         except Exception as e:
             logger.error(f"Failed to import task {task.key}: {e}")
@@ -595,19 +629,38 @@ class Fleet:
 
         Returns:
             List[Task] containing imported Task objects
+
+        Raises:
+            ValueError: If any task is missing verifier_func or has invalid verifier code
         """
         with open(filename, "r", encoding="utf-8") as f:
             tasks_data = json.load(f)
 
-        # Create tasks from the loaded data
+        # Create tasks from the loaded data using load_task_from_json
+        # This will validate and create verifiers properly
         tasks = []
         for task_data in tasks_data:
-            task = Task(**task_data)
+            # Validate that verifier_func exists
+            verifier_code = task_data.get("verifier_func") or task_data.get(
+                "verifier_code"
+            )
+            if not verifier_code:
+                task_key = task_data.get("key", task_data.get("id", "unknown"))
+                raise ValueError(
+                    f"Task {task_key} is missing verifier_func. "
+                    "All tasks must have a verifier_func to be imported."
+                )
+
+            # Use load_task_from_json to properly create and validate the task
+            # Pass raise_on_verifier_error=True to fail fast on invalid verifier code
+            task = self.load_task_from_json(task_data, raise_on_verifier_error=True)
             tasks.append(task)
 
         # Use ThreadPoolExecutor to parallelize the imports with max 20 workers
         with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
-            responses = list(executor.map(lambda t: self.import_single_task(t, project_key), tasks))
+            responses = list(
+                executor.map(lambda t: self.import_single_task(t, project_key), tasks)
+            )
 
         # Filter out None values (failed imports)
         return [r for r in responses if r is not None]

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,
     )
 
 
@@ -335,3 +354,44 @@ def update_task(
     return client.update_task(
         task_key=task_key, prompt=prompt, verifier_code=verifier_code
     )
+
+
+def import_task(task: Task, project_key: Optional[str] = None):
+    """Convenience function to import a single task.
+
+    Args:
+        task: Task object to import
+        project_key: Optional project key to associate with the task
+
+    Returns:
+        Response from the API, or None if the import failed
+
+    Examples:
+        task = fleet.Task(key="my-task", prompt="Do something", env_id="my-env")
+        response = fleet.import_task(task)
+        response = fleet.import_task(task, project_key="my-project")
+    """
+    from .global_client import get_client
+
+    client = get_client()
+    return client.import_single_task(task, project_key=project_key)
+
+
+def import_tasks(filename: str, project_key: Optional[str] = None):
+    """Convenience function to import tasks from a JSON file.
+
+    Args:
+        filename: Path to the JSON file of Task objects to import
+        project_key: Optional project key to associate with the tasks
+
+    Returns:
+        List of responses from the API for successfully imported tasks
+
+    Examples:
+        responses = fleet.import_tasks("tasks.json")
+        responses = fleet.import_tasks("tasks.json", project_key="my-project")
+    """
+    from .global_client import get_client
+
+    client = get_client()
+    return client.import_tasks(filename, project_key=project_key)

{fleet_python-0.2.53.dist-info → fleet_python-0.2.55.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.53
+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.53.dist-info → fleet_python-0.2.55.dist-info}/RECORD

@@ -11,7 +11,9 @@ examples/example_sync.py,sha256=EkuWmUzB1ZsBJQk6ZRflB793rKsuRHeSg5HJZHVhBB0,975
 examples/example_task.py,sha256=dhG6STAkNsTdHs9cO1RFH9WfuvRmq5bRC211hTeFrk8,7088
 examples/example_tasks.py,sha256=xTL8UWVAuolSX6swskfrAcmDrLIzn45dJ7YPWCwoEBU,514
 examples/example_verifier.py,sha256=0vwNITIG3m4CkSPwIxNXcGx9TqrxEsCGqK2A8keKZMM,2392
+examples/export_tasks.py,sha256=BSRmsGIIk34QYanB8rPlaFbmn3MBxaf7TyFVrbsdPeU,2114
 examples/gemini_example.py,sha256=qj9WDazQTYNiRHNeUg9Tjkp33lJMwbx8gDfpFe1sDQo,16180
+examples/import_tasks.py,sha256=pb60dOXnOn-G1INQxV1wujeHmmY2oWz9Ddj9SbMm1pk,3139
 examples/json_tasks_example.py,sha256=CYPESGGtOo0fmsDdLidujTfsE4QlJHw7rOhyVqPJ_Ls,5329
 examples/nova_act_example.py,sha256=rH23Lp74Okf0rn8ynMdWjK2aviEf5NLPH4k_53Pyxho,831
 examples/openai_example.py,sha256=dEWERrTEP5xBiGkLkQjBQGd2NqoxX6gcW6XteBPsWFQ,8231
@@ -19,22 +21,22 @@ examples/openai_simple_example.py,sha256=HmiufucrAZne7tHq9uoEsDWlEhjNC265bQAyIGB
 examples/query_builder_example.py,sha256=-cOMfWGNifYfYEt_Ds73XpwATZvFDL6F4KTkVxdMjzg,3951
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
-fleet/__init__.py,sha256=Mkdeh45N47lnSv73Eehj92cGU-AImUitvDWJLFhEp0Y,3844
+fleet/__init__.py,sha256=fwIcuaJPPdLMdKPsazfz4EAPeJchl9MBN4nxs0YlOjw,4117
 fleet/base.py,sha256=bc-340sTpq_DJs7yQ9d2pDWnmJFmA1SwDB9Lagvqtb4,9182
-fleet/client.py,sha256=zu05ApXhJrKX7UiMF8TOY1yNWiHRGlYRAMBmhaCsOSo,27806
+fleet/client.py,sha256=0RwFXBdiBSK7ziTrUe2uzhHX14MxuboIQhMCoRMC300,30315
 fleet/config.py,sha256=uY02ZKxVoXqVDta-0IMWaYJeE1CTXF_fA9NI6QUutmU,319
 fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/global_client.py,sha256=frrDAFNM2ywN0JHLtlm9qbE1dQpnQJsavJpb7xSR_bU,1072
 fleet/models.py,sha256=d9eish0KO3t4VCNu8h8Q_6K1Xj-crYo5Fejtle0Ur28,13056
-fleet/tasks.py,sha256=uR94wq7SG4ymJYLq24F2iYn0el58C2Czb2oK-8rIs8s,12344
+fleet/tasks.py,sha256=nNGyeGgWvluzSatd_AHqj9nk8jJ5dgCySPODCaySJ8M,14487
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
-fleet/_async/__init__.py,sha256=x2esWn8yf2AMfzHRmSHtFkXcxbrSSXCZdJyrFnJldEo,7033
+fleet/_async/__init__.py,sha256=ruGtdMl9BRQRsJygNszPT89ZbMy6AYv1mmeYoB--r60,7557
 fleet/_async/base.py,sha256=oisVTQsx0M_yTmyQJc3oij63uKZ97MHz-xYFsWXxQE8,9202
-fleet/_async/client.py,sha256=TZJsEg43IiYPnSA3S48GRpwAYg1fehcHVbYHA3yUHXY,28266
+fleet/_async/client.py,sha256=uiYufTUAG3o_nseflp_DxW8yLe8JnprIxCwjZ4CsqoI,30751
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
 fleet/_async/models.py,sha256=GX-sRciZDenW2O7Qx9w_ftOkJyE4ph1-92WMq6lynHE,12856
-fleet/_async/tasks.py,sha256=hrtvKlqepQOFnlJv6h5S06UWNWtn2hQlgSp3eYj5m30,12226
+fleet/_async/tasks.py,sha256=6EzoIuU-LuL-m716_ACV4oO3fNO_3Y1mAzrQ6MZDdwc,14441
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/_async/env/client.py,sha256=C5WG5Ir_McXaFPZNdkQjj0w4V7xMIcw3QyVP5g-3kVk,1237
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
@@ -67,10 +69,10 @@ fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,
 fleet/verifiers/parse.py,sha256=qz9AfJrTbjlg-LU-lE8Ciqi7Yt2a8-cs17FdpjTLhMk,8550
 fleet/verifiers/sql_differ.py,sha256=TqTLWyK3uOyLbitT6HYzYEzuSFC39wcyhgk3rcm__k8,6525
 fleet/verifiers/verifier.py,sha256=_lcxXVm8e0xRrK2gNJy9up7pW1zOkPRY5n5lQ85S8jg,14197
-fleet_python-0.2.53.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_python-0.2.55.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 scripts/fix_sync_imports.py,sha256=X9fWLTpiPGkSHsjyQUDepOJkxOqw1DPj7nd8wFlFqLQ,8368
 scripts/unasync.py,sha256=vWVQxRWX8SRZO5cmzEhpvnG_REhCWXpidIGIpWmEcvI,696
-fleet_python-0.2.53.dist-info/METADATA,sha256=SaC_PN_pQ1GG1g3RdaitFUy0PJWpD-1-hCIOT4sqcn8,3304
-fleet_python-0.2.53.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.53.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.53.dist-info/RECORD,,
+fleet_python-0.2.55.dist-info/METADATA,sha256=XOtlVrz0SxTxmvmv_EMP4UOhd-T7RJzXaHtPC9vCtzs,3304
+fleet_python-0.2.55.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.55.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.55.dist-info/RECORD,,