fleet-python 0.2.27__py3-none-any.whl → 0.2.29__py3-none-any.whl

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/_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/_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/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/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/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/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.dist-info → fleet_python-0.2.29.dist-info}/METADATA

@@ -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.dist-info → fleet_python-0.2.29.dist-info}/RECORD

@@ -18,19 +18,20 @@ examples/query_builder_example.py,sha256=Q3lUBETHpu1aS2FXAO79ADYqCxOjMMMZNgCcFVa
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 fleet/__init__.py,sha256=2WHAk_ZRIxDs1uxrWf-sSeokiK4f_nDVHJJ1_VUFSPA,2306
 fleet/base.py,sha256=0yYuMN0lBkrfTTZBt5NQp5112xWgziuWEk4GuHJB1wE,9189
-fleet/client.py,sha256=Nb4m6AX7uG6k0hdNqyBzAcEdYu1kJLicUnzvTAE_u8Y,20242
+fleet/client.py,sha256=GxpQufucXEJedb0MWE1wZL1G40CLV1c-GzUsUYNSxmU,22475
 fleet/config.py,sha256=rqR-y2TbZS-VYACaqrg-PUe0y0UDbR1ZNU1KGJZBwNQ,272
 fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/models.py,sha256=6SqoWdTIygF3jriZW53a-jQ1JZoPatuWZ4JQ1qIY5MY,12453
+fleet/tasks.py,sha256=koyaRk-ytn4yM5oOpGLHrY73KxtJyyJHsdhUFpTjPkk,3400
 fleet/types.py,sha256=eXeI8BFmiU5hln0PVvJbUZs7BSjl6wSqAtN9zaJT6yY,652
 fleet/_async/__init__.py,sha256=AJWCnuo7XKja4yBb8fK2wX7ntciLXQrpzdRHwjTRP6M,62
 fleet/_async/base.py,sha256=s0rYOtXsMJeitOvpa-Oh8ciLV226p_TIPp3fplzWvV4,9209
-fleet/_async/client.py,sha256=O2LB8FyJ4rGzAuE8nAeycYZAACQGPPENMKS7YDhTOmA,20388
+fleet/_async/client.py,sha256=DMLjGtLpeDzl2bJ8VO753IzzvLaR0l9TeP5C8fmlfio,22382
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/models.py,sha256=6SqoWdTIygF3jriZW53a-jQ1JZoPatuWZ4JQ1qIY5MY,12453
-fleet/_async/tasks.py,sha256=CJDt3dhg_88bHUYVqp2WcVenh6Y41wvp_iMaRiJeFDs,4069
+fleet/_async/tasks.py,sha256=WXZNGHYzNBeG5QF6EjOMNFpR5x3XZMdAwuwxZRTwFJI,4231
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/env/client.py,sha256=MR2Ju7AudGWmztTVUPPut-ys3yqD7D00D_jsxZaRybA,858
+fleet/_async/env/client.py,sha256=LJ0P9Dn06RhmzVCC9hnTTqd9k0LcWOaQ5nm4G7y1sOY,969
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
 fleet/_async/instance/base.py,sha256=3qUBuUR8OVS36LzdP6KyZzngtwPKYO09HoY6Ekxp-KA,1625
 fleet/_async/instance/client.py,sha256=2ZNoBxRJXDQc8fohCLy_RNo-wmuUKXzJo5RZQeCQnkQ,6069
@@ -41,8 +42,8 @@ fleet/_async/resources/sqlite.py,sha256=DvDLRI5dJ7_v4WkHw-Zday1M_FQUdzAqUCy9FtfO
 fleet/_async/verifiers/__init__.py,sha256=7dtLOFgirYQmEIiDMcx02-ZqR7yqrfjOiqBBuXBz914,466
 fleet/_async/verifiers/bundler.py,sha256=A4yR3wBOcVZYFAv87CD58QlJn6L4QXeilrasnVm8n74,26185
 fleet/_async/verifiers/verifier.py,sha256=vS2Nv-tLgDa_1xhMHdkw0297uNMzzSlRPsXe4zIJsqw,14528
-fleet/env/__init__.py,sha256=Wt6mO2dQnOdzdjOCvtiIP49wpSrmS7OaZ_OeHNrzqsY,595
-fleet/env/client.py,sha256=2FzA7qfR-B7tVdCNa4uQk10g8zXV-9MNjAqx2D5vQ7c,710
+fleet/env/__init__.py,sha256=w88In82IhmuGpRMW-bPlWGLTqdSWH2ic9eU6-8L8Rps,631
+fleet/env/client.py,sha256=WbjtYME1N4_Z88HDoLtsrNHRw8N5XNuXvRK8w48K-So,796
 fleet/instance/__init__.py,sha256=-Anms7Vw_FO8VBIvwnAnq4rQjwl_XNfAS-i7bypHMow,478
 fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
 fleet/instance/client.py,sha256=0gNXWRKNSXUqVTf6E5VUFO2gEZrBTF87QnvpLr5xaD8,5895
@@ -60,10 +61,10 @@ fleet/verifiers/decorator.py,sha256=Q-KHhicnIYFwX7FX_VZguzNfu8ZslqNUeWxcS2CwNVY,
 fleet/verifiers/parse.py,sha256=W4cBnto-XfPNrRwsYs7PFR3QJoI5UfWyB-QWsm1jUEg,7844
 fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
 fleet/verifiers/verifier.py,sha256=7yiqko332lX0pgjbyAQ6KbaGm_V8TX864ceH-4fvvW0,14470
-fleet_python-0.2.27.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_python-0.2.29.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 scripts/fix_sync_imports.py,sha256=m2OHz1lCAdDVIRhPvn8grNXpRaPo1b99dRMYI7TiEes,7117
 scripts/unasync.py,sha256=--Fmaae47o-dZ1HYgX1c3Nvi-rMjcFymTRlJcWWnmpw,725
-fleet_python-0.2.27.dist-info/METADATA,sha256=LS8LDwtM3SwLodzsypJJRxoaag9-9pP5cMvYD5yUkas,3347
-fleet_python-0.2.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.27.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.27.dist-info/RECORD,,
+fleet_python-0.2.29.dist-info/METADATA,sha256=jEanmSO_HJs7L4Xhw0a_iWu5SPqVH9F3ieqV94BmVBA,3347
+fleet_python-0.2.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.29.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.29.dist-info/RECORD,,