fleet-python 0.2.44__tar.gz → 0.2.46__tar.gz

{fleet_python-0.2.44 → fleet_python-0.2.46}/PKG-INFO

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

{fleet_python-0.2.44 → fleet_python-0.2.46}/fleet/_async/tasks.py

@@ -24,7 +24,9 @@ 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)"
+        None, 
+        description="Verifier function with decorator (async or sync)",
+        exclude=True  # Exclude from JSON serialization
     )
     verifier_id: Optional[str] = Field(None, description="Verifier identifier")
     verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
@@ -63,6 +65,10 @@ class Task(BaseModel):
         For sync environments, calls the sync verifier directly.
         For async verifiers, automatically runs them with asyncio.run().
         """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+            
         if self.verifier:
             import asyncio
             import inspect
@@ -93,6 +99,10 @@ class Task(BaseModel):
         For async environments, awaits the async verifier.
         Works with both sync and async verifiers in async contexts.
         """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+            
         if self.verifier:
             result = self.verifier.remote(*args, **kwargs)
             # If it's a coroutine, await it
@@ -105,6 +115,19 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
+    def _rebuild_verifier(self):
+        """Rebuild the verifier from verifier_func string if it exists."""
+        if self.verifier_func:
+            # Use the same logic as in verifier_from_string
+            verifier_id = self.verifier_id or self.key
+            verifier = verifier_from_string(
+                verifier_func=self.verifier_func,
+                verifier_id=verifier_id,
+                verifier_key=self.key,
+                sha256=self.verifier_sha or "",
+            )
+            self.verifier = verifier
+    
     async def make_env(self, region: Optional[str] = None):
         """Create an environment instance for this task's environment.
 

{fleet_python-0.2.44 → fleet_python-0.2.46}/fleet/_async/verifiers/verifier.py

@@ -12,7 +12,7 @@ import uuid
 import logging
 import hashlib
 import asyncio
-from typing import Any, Callable, Dict, Optional, List, TypeVar, Set, Tuple
+from typing import Any, Callable, Dict, Optional, List, TypeVar, Tuple
 
 from .bundler import FunctionBundler
 from ..client import AsyncEnv
@@ -21,8 +21,7 @@ logger = logging.getLogger(__name__)
 
 F = TypeVar("F", bound=Callable[..., Any])
 
-# Global cache to track which bundle SHAs have been uploaded to S3
-_uploaded_bundle_shas: Set[str] = set()
+# Removed global cache - always check server for bundle status
 
 
 @functools.lru_cache(maxsize=128)
@@ -107,25 +106,16 @@ class AsyncVerifierFunction:
             logger.debug(f"Using server-side bundle {bundle_sha[:8]}...")
             return bundle_sha, False  # No upload needed, server has it
 
-        # 1. Check local process cache first
-        if bundle_sha in _uploaded_bundle_shas:
-            logger.debug(f"Bundle {bundle_sha[:8]}... found in local cache")
-            return bundle_sha, False  # Already uploaded, no upload needed
-
-        # 2. Check if bundle exists on server (pseudocode)
-        # TODO: Add endpoint to check if bundle SHA exists in S3
+        # Always check if bundle exists on server
         try:
             exists = await env.check_bundle_exists(bundle_sha)
             if exists.success:
-                logger.info(
-                    f"Bundle {bundle_sha[:8]}... found on server, updating cache"
-                )
-                _uploaded_bundle_shas.add(bundle_sha)
+                logger.info(f"Bundle {bundle_sha[:8]}... found on server")
                 return bundle_sha, False  # Found on server, no upload needed
         except Exception as e:
             logger.warning(f"Failed to check bundle existence: {e}")
 
-        # 3. Bundle not found locally or on server - upload needed
+        # Bundle not found on server - upload needed
         logger.info(f"Bundle {bundle_sha[:8]}... needs to be uploaded")
         return bundle_sha, True  # Upload needed
 
@@ -194,9 +184,7 @@ class AsyncVerifierFunction:
                     needs_upload=True,
                 )
 
-                # Mark as uploaded after successful execution
-                _uploaded_bundle_shas.add(bundle_sha)
-                logger.debug(f"Registered bundle {bundle_sha[:8]}... as uploaded")
+                logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
 
             else:
                 # Bundle already available - execute without upload

{fleet_python-0.2.44 → fleet_python-0.2.46}/fleet/client.py

@@ -579,6 +579,8 @@ class Fleet:
             task = Task(**task_data)
             tasks.append(task)
 
+        responses = []
+
         for task in tasks:
             payload = TaskRequest(
                 key=task.key,
@@ -592,10 +594,13 @@ class Fleet:
                 response = self.client.request(
                     "POST", "/v1/tasks", json=payload.model_dump()
                 )
+                responses.append(response)
             except Exception as e:
                 logger.error(f"Failed to import task {task.key}: {e}")
                 continue
 
+        return responses
+
     def account(self) -> AccountResponse:
         """Get account information including instance limits and usage.
 

{fleet_python-0.2.44 → fleet_python-0.2.46}/fleet/tasks.py

@@ -2,11 +2,9 @@
 
 from __future__ import annotations
 
-import re
 import asyncio
 from datetime import datetime
 from typing import Any, Dict, Optional, List
-from uuid import UUID
 
 from pydantic import BaseModel, Field, validator
 
@@ -27,7 +25,9 @@ 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)"
+        None,
+        description="Verifier function with decorator (async or sync)",
+        exclude=True,
     )
     verifier_id: Optional[str] = Field(None, description="Verifier identifier")
     verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
@@ -66,6 +66,10 @@ class Task(BaseModel):
         For sync environments, calls the sync verifier directly.
         For async verifiers, automatically runs them with asyncio.run().
         """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+
         if self.verifier:
             import inspect
 
@@ -96,6 +100,10 @@ class Task(BaseModel):
         For async environments, awaits the async verifier.
         Works with both sync and async verifiers in async contexts.
         """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+
         if self.verifier:
             result = self.verifier.remote(*args, **kwargs)
             # If it's a coroutine, await it
@@ -108,6 +116,19 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
+    def _rebuild_verifier(self):
+        """Rebuild the verifier from verifier_func string if it exists."""
+        if self.verifier_func:
+            # Use the same logic as in verifier_from_string
+            verifier_id = self.verifier_id or self.key
+            verifier = verifier_from_string(
+                verifier_func=self.verifier_func,
+                verifier_id=verifier_id,
+                verifier_key=self.key,
+                sha256=self.verifier_sha or "",
+            )
+            self.verifier = verifier
+
     def make_env(self, region: Optional[str] = None):
         """Create an environment instance for this task's environment.
 
@@ -245,7 +266,6 @@ def update_task(
         response = fleet.update_task("my-task", verifier_code="def verify(env): return True")
     """
     from .global_client import get_client
-    from .models import TaskResponse
 
     client = get_client()
     return client.update_task(

{fleet_python-0.2.44 → fleet_python-0.2.46}/fleet/verifiers/verifier.py

@@ -19,7 +19,6 @@ from typing import (
     Optional,
     List,
     TypeVar,
-    Set,
     TYPE_CHECKING,
     Tuple,
 )
@@ -33,8 +32,7 @@ logger = logging.getLogger(__name__)
 
 F = TypeVar("F", bound=Callable[..., Any])
 
-# Global cache to track which bundle SHAs have been uploaded to S3
-_uploaded_bundle_shas: Set[str] = set()
+# Removed global cache - always check server for bundle status
 
 
 @functools.lru_cache(maxsize=128)
@@ -119,25 +117,16 @@ class SyncVerifierFunction:
             logger.debug(f"Using server-side bundle {bundle_sha[:8]}...")
             return bundle_sha, False  # No upload needed, server has it
 
-        # 1. Check local process cache first
-        if bundle_sha in _uploaded_bundle_shas:
-            logger.debug(f"Bundle {bundle_sha[:8]}... found in local cache")
-            return bundle_sha, False  # Already uploaded, no upload needed
-
-        # 2. Check if bundle exists on server (pseudocode)
-        # TODO: Add endpoint to check if bundle SHA exists in S3
+        # Always check if bundle exists on server
         try:
             exists = env.check_bundle_exists(bundle_sha)
             if exists.success:
-                logger.info(
-                    f"Bundle {bundle_sha[:8]}... found on server, updating cache"
-                )
-                _uploaded_bundle_shas.add(bundle_sha)
+                logger.info(f"Bundle {bundle_sha[:8]}... found on server")
                 return bundle_sha, False  # Found on server, no upload needed
         except Exception as e:
             logger.warning(f"Failed to check bundle existence: {e}")
 
-        # 3. Bundle not found locally or on server - upload needed
+        # Bundle not found on server - upload needed
         logger.info(f"Bundle {bundle_sha[:8]}... needs to be uploaded")
         return bundle_sha, True  # Upload needed
 
@@ -206,9 +195,7 @@ class SyncVerifierFunction:
                     needs_upload=True,
                 )
 
-                # Mark as uploaded after successful execution
-                _uploaded_bundle_shas.add(bundle_sha)
-                logger.debug(f"Registered bundle {bundle_sha[:8]}... as uploaded")
+                logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
 
             else:
                 # Bundle already available - execute without upload

{fleet_python-0.2.44 → fleet_python-0.2.46}/fleet_python.egg-info/PKG-INFO

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

{fleet_python-0.2.44 → fleet_python-0.2.46}/pyproject.toml

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