fleet-python 0.2.124__tar.gz → 0.2.125__tar.gz

{fleet_python-0.2.124/fleet_python.egg-info → fleet_python-0.2.125}/PKG-INFO

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

{fleet_python-0.2.124 → fleet_python-0.2.125}/fleet/__init__.py

@@ -38,9 +38,6 @@ from .verifiers import (
     SnapshotDiff,
     TASK_FAILED_SCORE,
     TASK_SUCCESSFUL_SCORE,
-    execute_verifier_local,
-    LocalEnvironment,
-    diff_dbs,
 )
 
 # Import async verifiers (default verifier is async for modern usage)
@@ -79,7 +76,7 @@ from . import env
 from . import global_client as _global_client
 from ._async import global_client as _async_global_client
 
-__version__ = "0.2.124"
+__version__ = "0.2.125"
 
 __all__ = [
     # Core classes
@@ -117,9 +114,6 @@ __all__ = [
     "SnapshotDiff",
     "TASK_FAILED_SCORE",
     "TASK_SUCCESSFUL_SCORE",
-    "execute_verifier_local",
-    "LocalEnvironment",
-    "diff_dbs",
     # Environment module
     "env",
     # Global client helpers

{fleet_python-0.2.124 → fleet_python-0.2.125}/fleet/_async/__init__.py

@@ -44,7 +44,7 @@ from ..types import VerifierFunction
 from .. import env
 from . import global_client as _async_global_client
 
-__version__ = "0.2.124"
+__version__ = "0.2.125"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.124 → fleet_python-0.2.125}/fleet/_async/base.py

@@ -26,7 +26,7 @@ from .exceptions import (
 try:
     from .. import __version__
 except ImportError:
-    __version__ = "0.2.124"
+    __version__ = "0.2.125"
 
 logger = logging.getLogger(__name__)
 

{fleet_python-0.2.124 → fleet_python-0.2.125}/fleet/_async/client.py

@@ -601,6 +601,7 @@ class AsyncFleet:
         )
 
         instance = AsyncEnv(client=self.client, **response.json())
+        await instance.instance.load()
         return instance
 
     async def make_for_task(self, task: Task) -> AsyncEnv:
@@ -652,6 +653,7 @@ class AsyncFleet:
         else:
             response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
             instance = AsyncEnv(client=self.client, **response.json())
+            await instance.instance.load()
             return instance
 
     def _create_url_instance(self, base_url: str) -> AsyncEnv:
@@ -832,74 +834,7 @@ class AsyncFleet:
             At least one of run_id or profile_id must be provided.
         """
         return await _delete_instances_batch(self.client, run_id=run_id, profile_id=profile_id)
-
-    @staticmethod
-    async def execute_verifier_local(
-        verifier_func: str,
-        seed_db: str,
-        current_db: str,
-        final_answer: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """Execute a verifier function locally against SQLite database files.
-
-        No authentication or remote server required. The verifier code is executed
-        in an isolated namespace with the same helpers available in production
-        (``normalized_contains``, ``IgnoreConfig``, ``DatabaseSnapshot``, etc.).
-
-        Args:
-            verifier_func: Python source code containing the verifier function definition.
-            seed_db: Path to the seed (before) SQLite database file.
-            current_db: Path to the current (after) SQLite database file.
-            final_answer: Optional final answer string passed to the verifier.
-
-        Returns:
-            Dict with keys ``success``, ``result``, ``error``, and ``stdout``.
-
-        Example::
-
-            result = await fleet.execute_verifier_local(
-                verifier_func=verifier_code_string,
-                seed_db="./seed.db",
-                current_db="./current.db",
-            )
-            print(result["result"])  # 1 (TASK_SUCCESSFUL_SCORE) or 0
-        """
-        import asyncio
-        from ..verifiers.local_executor import execute_verifier_local
-
-        return await asyncio.to_thread(
-            execute_verifier_local, verifier_func, seed_db, current_db, final_answer
-        )
-
-    @staticmethod
-    async def diff_dbs(
-        seed_db: str,
-        current_db: str,
-        ignore_tables: Optional[set] = None,
-        ignore_table_fields: Optional[Dict[str, set]] = None,
-    ) -> Dict[str, Any]:
-        """Compute a structured diff between two local SQLite databases.
-
-        Returns the same format as the runner's ``/diff/structured`` endpoint.
-        No authentication or network access required.
-
-        Args:
-            seed_db: Path to the seed (before) SQLite database file.
-            current_db: Path to the current (after) SQLite database file.
-            ignore_tables: Optional set of table names to skip entirely.
-            ignore_table_fields: Optional mapping of ``{table: {field, ...}}``
-                to strip from the output.
-
-        Returns:
-            Dict with keys ``success``, ``diff``, and ``message``.
-        """
-        import asyncio
-        from ..verifiers.local_executor import diff_dbs
-
-        return await asyncio.to_thread(
-            diff_dbs, seed_db, current_db, ignore_tables, ignore_table_fields
-        )
-
+    
     async def list_runs(
         self, profile_id: Optional[str] = None, status: Optional[str] = "active"
     ) -> List[Run]:

{fleet_python-0.2.124 → fleet_python-0.2.125}/fleet/base.py

@@ -27,7 +27,7 @@ from .exceptions import (
 try:
     from . import __version__
 except ImportError:
-    __version__ = "0.2.124"
+    __version__ = "0.2.125"
 
 logger = logging.getLogger(__name__)
 

{fleet_python-0.2.124 → fleet_python-0.2.125}/fleet/client.py

@@ -613,6 +613,7 @@ class Fleet:
         )
 
         instance = SyncEnv(client=self.client, **response.json())
+        instance.instance.load()
         return instance
 
     def make_for_task(self, task: Task) -> SyncEnv:
@@ -664,6 +665,7 @@ class Fleet:
         else:
             response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
             instance = SyncEnv(client=self.client, **response.json())
+            instance.instance.load()
             return instance
 
     def _create_url_instance(self, base_url: str) -> SyncEnv:
@@ -844,68 +846,7 @@ class Fleet:
             At least one of run_id or profile_id must be provided.
         """
         return _delete_instances_batch(self.client, run_id=run_id, profile_id=profile_id)
-
-    @staticmethod
-    def execute_verifier_local(
-        verifier_func: str,
-        seed_db: str,
-        current_db: str,
-        final_answer: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """Execute a verifier function locally against SQLite database files.
-
-        No authentication or remote server required. The verifier code is executed
-        in an isolated namespace with the same helpers available in production
-        (``normalized_contains``, ``IgnoreConfig``, ``DatabaseSnapshot``, etc.).
-
-        Args:
-            verifier_func: Python source code containing the verifier function definition.
-            seed_db: Path to the seed (before) SQLite database file.
-            current_db: Path to the current (after) SQLite database file.
-            final_answer: Optional final answer string passed to the verifier.
-
-        Returns:
-            Dict with keys ``success``, ``result``, ``error``, and ``stdout``.
-
-        Example::
-
-            result = fleet.execute_verifier_local(
-                verifier_func=verifier_code_string,
-                seed_db="./seed.db",
-                current_db="./current.db",
-            )
-            print(result["result"])  # 1 (TASK_SUCCESSFUL_SCORE) or 0
-        """
-        from .verifiers.local_executor import execute_verifier_local
-
-        return execute_verifier_local(verifier_func, seed_db, current_db, final_answer)
-
-    @staticmethod
-    def diff_dbs(
-        seed_db: str,
-        current_db: str,
-        ignore_tables: Optional[set] = None,
-        ignore_table_fields: Optional[Dict[str, set]] = None,
-    ) -> Dict[str, Any]:
-        """Compute a structured diff between two local SQLite databases.
-
-        Returns the same format as the runner's ``/diff/structured`` endpoint.
-        No authentication or network access required.
-
-        Args:
-            seed_db: Path to the seed (before) SQLite database file.
-            current_db: Path to the current (after) SQLite database file.
-            ignore_tables: Optional set of table names to skip entirely.
-            ignore_table_fields: Optional mapping of ``{table: {field, ...}}``
-                to strip from the output.
-
-        Returns:
-            Dict with keys ``success``, ``diff``, and ``message``.
-        """
-        from .verifiers.local_executor import diff_dbs
-
-        return diff_dbs(seed_db, current_db, ignore_tables, ignore_table_fields)
-
+    
     def list_runs(
         self, profile_id: Optional[str] = None, status: Optional[str] = "active"
     ) -> List[Run]:

{fleet_python-0.2.124 → fleet_python-0.2.125}/fleet/judge.py

@@ -823,54 +823,6 @@ def _parse_grade_response(data: dict) -> JudgeResult:
     return JudgeResult(score, details=data)
 
 
-def _print_criteria_markers(criteria: list) -> None:
-    """Emit ``>>> CRITERIA >>>`` stdout markers for structured criteria display.
-
-    The orchestrator (theseus PR #1967) scans verifier stdout for these
-    markers and wraps the execution result so the client (client PR #1737)
-    can render an expandable rubric breakdown.
-
-    Converts from the orchestrator judge-response format::
-
-        {"name": str, "score": int, "max_score": int, "reasoning": str}
-
-    to the client-expected marker format::
-
-        {"criteria": str, "score": float, "score_out_of": float, "description"?: str}
-
-    Each criterion's score is normalised to a 0.0–1.0 float using its own
-    ``max_score``.
-    """
-    marker_criteria = []
-    for c in criteria:
-        name = c.get("name", "")
-        cscore = c.get("score", 0)
-        cmax = c.get("max_score", 0)
-
-        # Normalise per-criterion score to 0.0–1.0
-        if cmax and float(cmax) > 0:
-            norm_score = float(cscore) / float(cmax)
-        else:
-            norm_score = float(cscore)
-
-        entry: dict = {
-            "criteria": name,
-            "score": round(norm_score, 4),
-            "score_out_of": 1.0,
-        }
-
-        reasoning = c.get("reasoning", "")
-        if reasoning:
-            entry["description"] = reasoning
-
-        marker_criteria.append(entry)
-
-    if marker_criteria:
-        print(">>> CRITERIA >>>")
-        print(json.dumps(marker_criteria))
-        print("<<< CRITERIA <<<")
-
-
 def _print_judge_result(data: dict) -> None:
     """Print detailed judge grading result for verifier stdout capture."""
     model = data.get("model_used", "unknown")
@@ -896,12 +848,6 @@ def _print_judge_result(data: dict) -> None:
             if len(reasoning) > 200:
                 reasoning = reasoning[:200] + "..."
             print(f"[C]   {name}: {cscore}/{cmax} — {reasoning}")
-
-        # Emit structured criteria via stdout markers so the orchestrator
-        # (_extract_criteria_from_stdout) and client can render a rubric
-        # breakdown.  Schema per element:
-        #   {"criteria": str, "score": float, "score_out_of": float, "description"?: str}
-        _print_criteria_markers(criteria)
     else:
         print(f"[C] Score: {normalized:.2f}")
 

{fleet_python-0.2.124 → fleet_python-0.2.125}/fleet/verifiers/__init__.py

@@ -6,7 +6,6 @@ from .verifier import (
     verifier,
     SyncVerifierFunction,
 )
-from .local_executor import execute_verifier_local, LocalEnvironment, diff_dbs
 
 __all__ = [
     "DatabaseSnapshot",
@@ -16,7 +15,4 @@ __all__ = [
     "TASK_FAILED_SCORE",
     "verifier",
     "SyncVerifierFunction",
-    "execute_verifier_local",
-    "LocalEnvironment",
-    "diff_dbs",
 ]