fleet-python 0.2.34__tar.gz → 0.2.35__tar.gz

{fleet_python-0.2.34 → fleet_python-0.2.35}/PKG-INFO

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

{fleet_python-0.2.34 → fleet_python-0.2.35}/fleet/__init__.py

@@ -46,8 +46,11 @@ from ._async.verifiers import (
     AsyncVerifierFunction,
 )
 
-# Import async tasks (default tasks are async for modern usage)
-from ._async.tasks import Task
+# Import async tasks (default tasks are async for modern usage)  
+from ._async.tasks import Task, load_tasks
+
+# Import sync load_tasks function
+from .tasks import load_tasks as load_tasks_sync
 
 # Import shared types
 from .types import VerifierFunction
@@ -94,19 +97,14 @@ __all__ = [
     "configure",
     "get_client",
     "reset_client",
+    # Module-level functions (async is default)
+    "load_tasks",
+    "load_tasks_sync",
     # Version
     "__version__",
 ]
 
 
-def load_tasks(env_key: Optional[str] = None) -> List[Task]:
-    """Load tasks without explicitly creating a client.
-
-    Example:
-        tasks = fleet.load_tasks(env_key="fira")
-    """
-    # Use global client by default so users can configure once
-    return _global_client.get_client().load_tasks(env_key=env_key)
 
 
 def configure(

{fleet_python-0.2.34 → fleet_python-0.2.35}/fleet/_async/__init__.py

@@ -35,7 +35,7 @@ from .verifiers import (
 )
 
 # Import async tasks
-from .tasks import Task
+from .tasks import Task, load_tasks
 
 # Import shared types
 from ..types import VerifierFunction
@@ -93,33 +93,6 @@ __all__ = [
 ]
 
 
-async def load_tasks(
-    env_key: Optional[str] = None,
-    keys: Optional[List[str]] = None,
-    version: Optional[str] = None,
-    team_id: Optional[str] = None
-) -> List[Task]:
-    """Load tasks with optional filtering.
-
-    Args:
-        env_key: Optional environment key to filter tasks by
-        keys: Optional list of task keys to filter by
-        version: Optional 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")
-    """
-    # Use global client by default so users can configure once
-    return await _async_global_client.get_client().load_tasks(
-        env_key=env_key, 
-        keys=keys, 
-        version=version, 
-        team_id=team_id
-    )
-
-
 async def list_envs() -> List[Environment]:
     """List all available environments."""
     return await _async_global_client.get_client().list_envs()

{fleet_python-0.2.34 → fleet_python-0.2.35}/fleet/_async/client.py

@@ -50,7 +50,7 @@ from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import AsyncSQLiteResource
 from .resources.browser import AsyncBrowserResource
-from ..resources.mcp import MCPResource
+from .resources.mcp import AsyncMCPResource
 
 logger = logging.getLogger(__name__)
 
@@ -105,9 +105,9 @@ class AsyncEnv(EnvironmentBase):
         return self.instance.browser(name)
 
     @property
-    def mcp(self) -> MCPResource:
+    def mcp(self) -> AsyncMCPResource:
         mcp_url = f"{self.urls.root}mcp"
-        return MCPResource(url=mcp_url, env_key=self.env_key)
+        return AsyncMCPResource(url=mcp_url, env_key=self.env_key)
 
     def state(self, uri: str) -> Resource:
         return self.instance.state(uri)
@@ -507,12 +507,6 @@ class AsyncFleet:
             sha256=verifier_sha,
         )
         
-        # Ensure we return an AsyncVerifierFunction
-        if not isinstance(verifier_func, AsyncVerifierFunction):
-            raise TypeError(
-                f"Expected AsyncVerifierFunction but got {type(verifier_func).__name__}"
-            )
-        
         # Store the original verifier code for reference
         verifier_func._verifier_code = verifier_code
 

{fleet_python-0.2.34 → fleet_python-0.2.35}/fleet/_async/tasks.py

@@ -125,6 +125,56 @@ class Task(BaseModel):
         return await AsyncFleet().make(env_key=self.env_key, region=region)
 
 
+def verifier_from_string(
+    verifier_func: str,
+    verifier_id: str,
+    verifier_key: str,
+    sha256: str = ""
+) -> 'VerifierFunction':
+    """Create a verifier function from string code.
+    
+    Args:
+        verifier_func: The verifier function code as a string
+        verifier_id: Unique identifier for the verifier
+        verifier_key: Key/name for the verifier
+        sha256: SHA256 hash of the verifier code
+        
+    Returns:
+        VerifierFunction instance that can be used to verify tasks
+    """
+    try:
+        import inspect
+        from .verifiers import verifier, AsyncVerifierFunction
+        
+        # Create a local namespace for executing the code
+        local_namespace = {}
+        
+        # Execute the verifier code in the namespace
+        exec(verifier_func, globals(), local_namespace)
+        
+        # Find the function that was defined
+        func_obj = None
+        for name, obj in local_namespace.items():
+            if inspect.isfunction(obj):
+                func_obj = obj
+                break
+        
+        if func_obj is None:
+            raise ValueError("No function found in verifier code")
+        
+        # Create an AsyncVerifierFunction instance
+        verifier_instance = AsyncVerifierFunction(func_obj, verifier_key, verifier_id)
+        
+        # Store additional metadata
+        verifier_instance._verifier_code = verifier_func
+        verifier_instance._sha256 = sha256
+        
+        return verifier_instance
+        
+    except Exception as e:
+        raise ValueError(f"Failed to create verifier from string: {e}")
+
+
 async def load_tasks(
     env_key: Optional[str] = None,
     keys: Optional[List[str]] = None,

{fleet_python-0.2.34 → fleet_python-0.2.35}/fleet/client.py

@@ -50,7 +50,7 @@ from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import SQLiteResource
 from .resources.browser import BrowserResource
-from ..resources.mcp import MCPResource
+from .resources.mcp import SyncMCPResource
 
 logger = logging.getLogger(__name__)
 
@@ -105,9 +105,9 @@ class SyncEnv(EnvironmentBase):
         return self.instance.browser(name)
 
     @property
-    def mcp(self) -> MCPResource:
+    def mcp(self) -> SyncMCPResource:
         mcp_url = f"{self.urls.root}mcp"
-        return MCPResource(url=mcp_url, env_key=self.env_key)
+        return SyncMCPResource(url=mcp_url, env_key=self.env_key)
 
     def state(self, uri: str) -> Resource:
         return self.instance.state(uri)
@@ -496,14 +496,8 @@ class Fleet:
         Returns:
             AsyncVerifierFunction created from the verifier code
         """
-        from ..tasks import verifier_from_string
-        from .verifiers.verifier import SyncVerifierFunction
-
-        # Convert async verifier code to sync
-        if 'async def' in verifier_code:
-            verifier_code = verifier_code.replace('async def', 'def')
-        if 'await ' in verifier_code:
-            verifier_code = verifier_code.replace('await ', '')
+        from .tasks import verifier_from_string
+        from .verifiers import SyncVerifierFunction
         
         # Use verifier_from_string to create the verifier
         verifier_func = verifier_from_string(
@@ -513,12 +507,6 @@ class Fleet:
             sha256=verifier_sha,
         )
         
-        # Ensure we return an AsyncVerifierFunction
-        if not isinstance(verifier_func, SyncVerifierFunction):
-            raise TypeError(
-                f"Expected AsyncVerifierFunction but got {type(verifier_func).__name__}"
-            )
-        
         # Store the original verifier code for reference
         verifier_func._verifier_code = verifier_code
 

{fleet_python-0.2.34 → fleet_python-0.2.35}/fleet/env/__init__.py

@@ -2,7 +2,7 @@
 
 from .client import (
     make,
-    make_for_task,
+    make_for_task_async,
     list_envs,
     list_regions,
     get,
@@ -22,7 +22,7 @@ from .._async.env.client import (
 
 __all__ = [
     "make",
-    "make_for_task",
+    "make_for_task_async",
     "list_envs",
     "list_regions",
     "list_instances",

{fleet_python-0.2.34 → fleet_python-0.2.35}/fleet/global_client.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Optional
 
 from .client import Fleet
-from ..config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
+from .config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
 
 
 _default_client: Optional[Fleet] = None

{fleet_python-0.2.34 → fleet_python-0.2.35}/fleet/tasks.py

@@ -124,6 +124,56 @@ class Task(BaseModel):
         return Fleet().make(env_key=self.env_key, region=region)
 
 
+def verifier_from_string(
+    verifier_func: str,
+    verifier_id: str,
+    verifier_key: str,
+    sha256: str = ""
+) -> 'VerifierFunction':
+    """Create a verifier function from string code.
+    
+    Args:
+        verifier_func: The verifier function code as a string
+        verifier_id: Unique identifier for the verifier
+        verifier_key: Key/name for the verifier
+        sha256: SHA256 hash of the verifier code
+        
+    Returns:
+        VerifierFunction instance that can be used to verify tasks
+    """
+    try:
+        import inspect
+        from .verifiers import verifier, SyncVerifierFunction
+        
+        # Create a local namespace for executing the code
+        local_namespace = {}
+        
+        # Execute the verifier code in the namespace
+        exec(verifier_func, globals(), local_namespace)
+        
+        # Find the function that was defined
+        func_obj = None
+        for name, obj in local_namespace.items():
+            if inspect.isfunction(obj):
+                func_obj = obj
+                break
+        
+        if func_obj is None:
+            raise ValueError("No function found in verifier code")
+        
+        # Create an AsyncVerifierFunction instance
+        verifier_instance = SyncVerifierFunction(func_obj, verifier_key, verifier_id)
+        
+        # Store additional metadata
+        verifier_instance._verifier_code = verifier_func
+        verifier_instance._sha256 = sha256
+        
+        return verifier_instance
+        
+    except Exception as e:
+        raise ValueError(f"Failed to create verifier from string: {e}")
+
+
 def load_tasks(
     env_key: Optional[str] = None,
     keys: Optional[List[str]] = None,

{fleet_python-0.2.34 → fleet_python-0.2.35}/fleet_python.egg-info/PKG-INFO

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

{fleet_python-0.2.34 → fleet_python-0.2.35}/pyproject.toml

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