fleet-python 0.2.27__tar.gz → 0.2.29__tar.gz

{fleet_python-0.2.27 → fleet_python-0.2.29}/PKG-INFO

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

{fleet_python-0.2.27 → fleet_python-0.2.29}/fleet/_async/client.py

@@ -213,6 +213,9 @@ class AsyncFleet:
         await instance.instance.load()
         return instance
 
+    async def make_for_task(self, task: Task) -> AsyncEnv:
+        return self.make(env_key=f"{task.env_id}:{task.version}")
+
     async def instances(
         self, status: Optional[str] = None, region: Optional[str] = None
     ) -> List[AsyncEnv]:
@@ -247,6 +250,50 @@ class AsyncFleet:
     async def delete(self, instance_id: str) -> InstanceResponse:
         return await _delete_instance(self.client, instance_id)
 
+    async def load_tasks_from_file(self, filename: str) -> List[Task]:
+        with open(filename, 'r', encoding='utf-8') as f:
+            tasks_data = f.read()
+
+        return self.load_task_array_from_string(tasks_data)
+
+    async def load_task_array_from_string(self, serialized_tasks: List[Dict]) -> List[Task]:
+        tasks = []
+
+        json_tasks = json.loads(serialized_tasks)
+        for json_task in json_tasks:
+            parsed_task = self.load_task_from_json(json_task)
+            tasks.append(parsed_task)
+        return tasks
+
+    async def load_task_from_string(self, task_string: str) -> Task:
+        task_json = json.loads(task_string)
+        return self.load_task_from_json(task_json)
+
+    async def load_task_from_json(self, task_json: Dict) -> Task:
+        try:
+            if 'verifier_id' in task_json and task_json['verifier_id']:
+                verifier = self._create_verifier_from_data(
+                    verifier_id=task_json['verifier_id'],
+                    verifier_key=task_json['key'],
+                    verifier_code=task_json['verifier_func'],
+                    verifier_sha=task_json.get('verifier_sha', '')
+                )
+        except Exception as e:
+            logger.warning(f"Failed to create verifier {task_json['key']}: {e}")
+        
+        task = Task(
+            key=task_json['key'],
+            prompt=task_json['prompt'],
+            env_id=task_json['env_id'],  # Use env_id from the data
+            created_at=task_json['created_at'],
+            version=task_json.get('version'),
+            env_variables=task_json.get('env_variables', {}),
+            verifier_func=task_json.get('verifier_func'),  # Set verifier code
+            verifier=verifier,  # Use created verifier or None
+            metadata=task_json.get('metadata', {})  # Default empty metadata
+        )
+        return task
+
     async def load_tasks(self, env_key: Optional[str] = None) -> List[Task]:
         """Load tasks for the authenticated team, optionally filtered by environment.
         

{fleet_python-0.2.27 → fleet_python-0.2.29}/fleet/_async/env/client.py

@@ -1,4 +1,4 @@
-from ..client import AsyncFleet, AsyncEnv
+from ..client import AsyncFleet, AsyncEnv, Task
 from ...models import Environment as EnvironmentModel, AccountResponse
 from typing import List, Optional
 
@@ -6,6 +6,8 @@ from typing import List, Optional
 async def make_async(env_key: str, region: Optional[str] = None) -> AsyncEnv:
     return await AsyncFleet().make(env_key, region=region)
 
+async def make_for_task_async(task: Task) -> AsyncEnv:
+    return await AsyncFleet().make_for_task(task)
 
 async def list_envs_async() -> List[EnvironmentModel]:
     return await AsyncFleet().list_envs()

{fleet_python-0.2.27 → fleet_python-0.2.29}/fleet/_async/tasks.py

@@ -24,6 +24,8 @@ class Task(BaseModel):
     version: Optional[str] = Field(None, description="Task version")
     verifier_func: Optional[str] = Field(None, description="Verifier function code")
     verifier: Optional[Any] = Field(None, description="Verifier function with decorator (async or sync)")
+    verifier_id: Optional[str] = Field(None, description="Verifier identifier")
+    verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
     metadata: Optional[Dict[str, Any]] = Field(default_factory=dict, description="Additional task metadata")
 
     @validator('key')

{fleet_python-0.2.27 → fleet_python-0.2.29}/fleet/client.py

@@ -213,6 +213,9 @@ class Fleet:
         instance.instance.load()
         return instance
 
+    def make_for_task(self, task: Task) -> SyncEnv:
+        return self.make(env_key=f"{task.env_id}:{task.version}")
+
     def instances(
         self, status: Optional[str] = None, region: Optional[str] = None
     ) -> List[SyncEnv]:
@@ -246,8 +249,54 @@ class Fleet:
 
     def delete(self, instance_id: str) -> InstanceResponse:
         return _delete_instance(self.client, instance_id)
+    
+    def load_tasks_from_file(self, filename: str) -> List[Task]:
+        with open(filename, 'r', encoding='utf-8') as f:
+            tasks_data = f.read()
+
+        return self.load_task_array_from_string(tasks_data)
+
+    def load_task_array_from_string(self, serialized_tasks: List[Dict]) -> List[Task]:
+        tasks = []
+
+        json_tasks = json.loads(serialized_tasks)
+        for json_task in json_tasks:
+            parsed_task = self.load_task_from_json(json_task)
+            tasks.append(parsed_task)
+        return tasks
+
+    def load_task_from_string(self, task_string: str) -> Task:
+        task_json = json.loads(task_string)
+        return self.load_task_from_json(task_json)
+
+    def load_task_from_json(self, task_json: Dict) -> Task:
+        verifier = None
+        try:
+            if 'verifier_id' in task_json and task_json['verifier_id']:
+                verifier = self._create_verifier_from_data(
+                    verifier_id=task_json['verifier_id'],
+                    verifier_key=task_json['key'],
+                    verifier_code=task_json['verifier_func'],
+                    verifier_sha=task_json.get('verifier_sha', '')
+                )
+        except Exception as e:
+            logger.warning(f"Failed to create verifier {task_json['key']}: {e}")
+        
+        task = Task(
+            key=task_json['key'],
+            prompt=task_json['prompt'],
+            env_id=task_json['env_id'],  # Use env_id from the data
+            created_at=task_json['created_at'],
+            version=task_json.get('version'),
+            env_variables=task_json.get('env_variables', {}),
+            verifier_func=task_json.get('verifier_func'),  # Set verifier code
+            verifier=verifier,  # Use created verifier or None
+            metadata=task_json.get('metadata', {})  # Default empty metadata
+        )
+        return task
 
-    def load_tasks(self, env_key: Optional[str] = None) -> List[Task]:
+
+    def load_tasks(self, env_key: Optional[str] = None, task_keys: Optional[List[str]] = None) -> List[Task]:
         """Load tasks for the authenticated team, optionally filtered by environment.
         
         Args:
@@ -259,6 +308,9 @@ class Fleet:
         params = {}
         if env_key is not None:
             params["env_key"] = env_key
+
+        if task_keys is not None:
+            params["task_keys"] = task_keys
             
         response = self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())
@@ -294,6 +346,8 @@ class Fleet:
                 env_variables=task_response.env_variables or {},
                 verifier_func=verifier_func,  # Set verifier code
                 verifier=verifier,  # Use created verifier or None
+                verifier_id=task_response.verifier.verifier_id,
+                verifier_sha=task_response.verifier.sha256,
                 metadata={}  # Default empty metadata
             )
             tasks.append(task)
@@ -371,7 +425,6 @@ class Fleet:
                 logger.error(f"Failed to import task {task.key}: {e}")
                 continue
 
-
     def account(self) -> AccountResponse:
         """Get account information including instance limits and usage.
 

{fleet_python-0.2.27 → fleet_python-0.2.29}/fleet/env/__init__.py

@@ -1,6 +1,6 @@
 """Fleet env module - convenience functions for environment management."""
 
-from .client import make, list_envs, list_regions, get, list_instances, account
+from .client import make, make_for_task, list_envs, list_regions, get, list_instances, account
 
 # Import async versions from _async
 from .._async.env.client import (
@@ -14,6 +14,7 @@ from .._async.env.client import (
 
 __all__ = [
     "make",
+    "make_for_task",
     "list_envs",
     "list_regions",
     "list_instances",

{fleet_python-0.2.27 → fleet_python-0.2.29}/fleet/env/client.py

@@ -1,4 +1,4 @@
-from ..client import Fleet, SyncEnv
+from ..client import Fleet, SyncEnv, Task
 from ..models import Environment as EnvironmentModel, AccountResponse
 from typing import List, Optional
 
@@ -6,11 +6,12 @@ from typing import List, Optional
 def make(env_key: str, region: Optional[str] = None) -> SyncEnv:
     return Fleet().make(env_key, region=region)
 
+def make_for_task(task: Task) -> SyncEnv:
+    return Fleet().make_for_task(task)
 
 def list_envs() -> List[EnvironmentModel]:
     return Fleet().list_envs()
 
-
 def list_regions() -> List[str]:
     return Fleet().list_regions()
 

fleet_python-0.2.29/fleet/tasks.py

@@ -0,0 +1,84 @@
+"""Fleet SDK Task Model."""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from typing import Any, Dict, Optional
+from uuid import UUID
+
+from pydantic import BaseModel, Field, validator
+
+# Import the shared VerifierFunction type that works for both async and sync
+from fleet.types import VerifierFunction
+
+
+class Task(BaseModel):
+    """A task model representing a single task in the Fleet system."""
+    
+    key: str = Field(..., description="Unique task key identifier")
+    prompt: str = Field(..., description="Task prompt or instruction")
+    env_id: str = Field(..., description="Environment identifier")
+    env_variables: Optional[Dict[str, Any]] = Field(default_factory=dict, description="Environment variables")
+    created_at: Optional[datetime] = Field(None, description="Task creation timestamp")
+    version: Optional[str] = Field(None, description="Task version")
+    verifier_func: Optional[str] = Field(None, description="Verifier function code")
+    verifier: Optional[Any] = Field(None, description="Verifier function with decorator (async or sync)")
+    verifier_id: Optional[str] = Field(None, description="Verifier identifier")
+    verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
+    metadata: Optional[Dict[str, Any]] = Field(default_factory=dict, description="Additional task metadata")
+
+    @validator('key')
+    def validate_key_format(cls, v):
+        """Validate key follows kebab-case format."""
+        if not re.match(r'^[a-z0-9]+(-[a-z0-9]+)*$', v):
+            raise ValueError(f'Invalid task key format: {v}. Must follow kebab-case format.')
+        return v
+
+    @validator('created_at', pre=True, always=True)
+    def set_created_at(cls, v):
+        """Set created_at to current time if not provided."""
+        return v or datetime.now()
+    
+    @property
+    def env_key(self) -> str:
+        """Get the environment key combining env_id and version."""
+        if self.version:
+            return f"{self.env_id}:{self.version}"
+        return self.env_id
+
+    class Config:
+        """Pydantic model configuration."""
+        json_encoders = {
+            datetime: lambda v: v.isoformat(),
+        }
+        # Allow arbitrary types for the verifier field
+        arbitrary_types_allowed = True 
+
+    def verify(self, env, *args, **kwargs) -> float:
+        """Verify the task using the verifier function (sync version).
+        
+        For sync environments, calls the sync verifier directly.
+        For async verifiers, automatically runs them with asyncio.run().
+        """
+        if self.verifier:
+            return self.verifier.remote(env, *args, **kwargs)
+        else:
+            raise ValueError("No verifier function found for this task")
+    
+    def verify_async(self, *args, **kwargs) -> float:
+        """Verify the task using the verifier function (async version).
+        
+        For async environments, awaits the async verifier.
+        Works with both sync and async verifiers in async contexts.
+        """
+        if self.verifier:
+            result = self.verifier.remote(*args, **kwargs)
+            # If it's a coroutine, await it
+            import inspect
+            if inspect.iscoroutine(result):
+                return result
+            else:
+                return result
+        else:
+            raise ValueError("No verifier function found for this task")

{fleet_python-0.2.27 → fleet_python-0.2.29}/fleet_python.egg-info/PKG-INFO

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

{fleet_python-0.2.27 → fleet_python-0.2.29}/fleet_python.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ fleet/client.py
 fleet/config.py
 fleet/exceptions.py
 fleet/models.py
+fleet/tasks.py
 fleet/types.py
 fleet/_async/__init__.py
 fleet/_async/base.py

{fleet_python-0.2.27 → fleet_python-0.2.29}/pyproject.toml

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