fleet-python 0.2.112__tar.gz → 0.2.114__tar.gz

{fleet_python-0.2.112/fleet_python.egg-info → fleet_python-0.2.114}/PKG-INFO

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

{fleet_python-0.2.112 → fleet_python-0.2.114}/fleet/__init__.py

@@ -76,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.112"
+__version__ = "0.2.114"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.112 → fleet_python-0.2.114}/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.112"
+__version__ = "0.2.114"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.112 → fleet_python-0.2.114}/fleet/_async/base.py

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

{fleet_python-0.2.112 → fleet_python-0.2.114}/fleet/_async/judge.py

@@ -12,7 +12,10 @@ from ..judge import (
     JudgeResult,
     Rubric,
     _build_grade_request,
+    _collect_image_from_env_async,
+    _guess_media_type,
     _parse_grade_response,
+    _print_judge_call_start,
 )
 
 if TYPE_CHECKING:
@@ -75,6 +78,29 @@ class AsyncJudge:
             collect: File patterns for orchestrator to collect (agentic mode).
             task_id: Optional task ID for tracking.
         """
+        # Resolve Image.from_env images asynchronously before building request
+        resolved_images = images
+        if images and not agentic:
+            resolved_images = {}
+            for label, img in images.items():
+                if img.source == "env" and img._env is not None:
+                    b64 = await _collect_image_from_env_async(img._env, img.filename)
+                    if b64 is not None:
+                        resolved_images[label] = Image.from_base64(
+                            b64,
+                            img.filename or "image.png",
+                            _guess_media_type(img.filename or "image.png"),
+                        )
+                    else:
+                        # Async collection failed — use collect source directly
+                        # (don't keep the env image or serialize() will retry sync)
+                        resolved_images[label] = Image(
+                            source="collect",
+                            filename=img.filename,
+                        )
+                else:
+                    resolved_images[label] = img
+
         body = _build_grade_request(
             self._instance_id,
             rubric,
@@ -84,7 +110,7 @@ class AsyncJudge:
             context=context,
             reference_claims=reference_claims,
             conversation=conversation,
-            images=images,
+            images=resolved_images,
             model=model,
             provider=provider,
             agentic=agentic,
@@ -92,5 +118,6 @@ class AsyncJudge:
             task_id=task_id,
         )
 
+        _print_judge_call_start(rubric, resolved_images, agentic, model)
         response = await self._client.request("POST", "/v1/judge/grade", json=body)
         return _parse_grade_response(response.json())

{fleet_python-0.2.112 → fleet_python-0.2.114}/fleet/base.py

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

{fleet_python-0.2.112 → fleet_python-0.2.114}/fleet/judge.py

@@ -176,6 +176,8 @@ class Image:
                 "data": self.data,
                 "media_type": self.media_type or _guess_media_type(self.filename or "image.png"),
             }
+        elif self.source == "collect":
+            d = {"source": "collect", "selector": self.filename}
         elif self.source == "env":
             if agentic:
                 d = {"source": "collect", "selector": self.filename}
@@ -330,6 +332,86 @@ def _collect_image_from_env(env: Any, filename: str) -> Optional[str]:
     return None
 
 
+async def _collect_image_from_env_async(env: Any, filename: str) -> Optional[str]:
+    """Async version of _collect_image_from_env.
+
+    Collects an image from an AsyncEnv using DB -> notebook -> filesystem strategies.
+    Returns base64-encoded image data, or None if not found.
+    """
+    # Strategy 1: DB files table
+    try:
+        current = env.db("current")
+        where = f"path = '{filename}' OR path LIKE '%/{filename}'"
+        rows = _extract_query_rows(
+            await current.query(f"SELECT path, hex(content) AS content_hex FROM files WHERE {where}")
+        )
+        candidates = {}
+        for row in rows:
+            path, chex = row.get("path", ""), row.get("content_hex", "")
+            if path and chex:
+                try:
+                    candidates[path] = bytes.fromhex(chex)
+                except Exception:
+                    pass
+        # Prefer non-dataroom paths
+        non_dr = [p for p in candidates if not p.startswith("dataroom/")]
+        best = sorted(non_dr or list(candidates.keys()), key=len)
+        if best:
+            logger.debug("Loaded image from DB (async): %s", best[0])
+            return base64.b64encode(candidates[best[0]]).decode()
+    except Exception as e:
+        logger.debug("DB image query failed (async): %s", e)
+
+    # Strategy 2: Notebook cell outputs
+    try:
+        current = env.db("current")
+        nb_rows = _extract_query_rows(
+            await current.query(
+                "SELECT path, hex(content) AS content_hex FROM files "
+                "WHERE path LIKE 'notebooks/%.ipynb'"
+            )
+        )
+        for nb_row in nb_rows:
+            chex = nb_row.get("content_hex", "")
+            if not chex:
+                continue
+            try:
+                nb_bytes = bytes.fromhex(chex)
+                nb = json.loads(nb_bytes.decode("utf-8"))
+                for cell in reversed(nb.get("cells", [])):
+                    for output in cell.get("outputs", []):
+                        if output.get("output_type") in ("display_data", "execute_result"):
+                            img_data = output.get("data", {}).get("image/png")
+                            if img_data:
+                                if isinstance(img_data, list):
+                                    img_data = "".join(img_data)
+                                img_data = img_data.strip()
+                                if img_data:
+                                    logger.debug("Loaded image from notebook (async): %s", nb_row.get("path"))
+                                    return img_data
+            except Exception:
+                pass
+    except Exception as e:
+        logger.debug("Notebook image query failed (async): %s", e)
+
+    # Strategy 3: Filesystem fallback
+    search_paths = [
+        filename,
+        f"/app/workspace/{filename}",
+        f"/workspace/{filename}",
+    ]
+    for fp in search_paths:
+        try:
+            if os.path.exists(fp):
+                with open(fp, "rb") as f:
+                    logger.debug("Loaded image from filesystem (async): %s", fp)
+                    return base64.b64encode(f.read()).decode()
+        except Exception:
+            pass
+
+    return None
+
+
 # ---------------------------------------------------------------------------
 # Accumulator printing (verifier protocol)
 # ---------------------------------------------------------------------------
@@ -359,6 +441,12 @@ def _print_accumulators(data: dict) -> None:
         print(json.dumps(grading_details))
         print("<<< GRADING_DETAILS <<<")
 
+    golden_urls = acc.get("golden_urls")
+    if golden_urls:
+        print(">>> GOLDEN_URLS >>>")
+        print(json.dumps(golden_urls))
+        print("<<< GOLDEN_URLS <<<")
+
     timing = acc.get("timing")
     if timing:
         print(
@@ -373,6 +461,34 @@ def _print_accumulators(data: dict) -> None:
 # ---------------------------------------------------------------------------
 
 
+def _print_judge_call_start(
+    rubric: Union[str, "Rubric"],
+    images: Optional[Dict[str, "Image"]],
+    agentic: bool,
+    model: Optional[str],
+) -> None:
+    """Print info when initiating a judge grading call."""
+    mode = "agentic" if agentic else "standard"
+    model_str = model or "default"
+    print(f"[C] Calling judge ({mode} mode, model={model_str})")
+
+    if isinstance(rubric, Rubric):
+        criteria_names = [c.name for c in rubric.criteria]
+        print(f"[C] Rubric: {len(rubric.criteria)} criteria ({', '.join(criteria_names)}), max={rubric.max_score}")
+
+    if images:
+        for label, img in images.items():
+            src = img.source
+            detail = ""
+            if img.url:
+                detail = f" url={img.url}"
+            elif img.filename:
+                detail = f" file={img.filename}"
+            print(f"[C] Image '{label}': source={src}{detail}")
+    else:
+        print("[C] No images provided")
+
+
 def _build_grade_request(
     instance_id: str,
     rubric: Union[str, Rubric],
@@ -443,11 +559,53 @@ def _build_grade_request(
 
 def _parse_grade_response(data: dict) -> JudgeResult:
     """Parse orchestrator response into JudgeResult and print accumulators."""
+    # Print detailed judge grading info
+    _print_judge_result(data)
     _print_accumulators(data)
     score = float(data.get("normalized_score", 0.0))
     return JudgeResult(score, details=data)
 
 
+def _print_judge_result(data: dict) -> None:
+    """Print detailed judge grading result for verifier stdout capture."""
+    model = data.get("model_used", "unknown")
+    provider = data.get("provider_used", "unknown")
+    total = data.get("total_score", 0)
+    max_score = data.get("max_score", 0)
+    normalized = data.get("normalized_score", 0)
+    elapsed = (data.get("accumulators") or {}).get("elapsed_ms")
+
+    print(f"[C] Grading via {model} (provider={provider})")
+    if elapsed is not None:
+        print(f"[C] Judge call completed in {elapsed:.0f}ms")
+
+    criteria = data.get("criteria")
+    if criteria:
+        print(f"[C] Score: {total}/{max_score} ({normalized:.2f})")
+        for c in criteria:
+            name = c.get("name", "?")
+            cscore = c.get("score", "?")
+            cmax = c.get("max_score", "?")
+            reasoning = c.get("reasoning", "")
+            # Truncate long reasoning for stdout readability
+            if len(reasoning) > 200:
+                reasoning = reasoning[:200] + "..."
+            print(f"[C]   {name}: {cscore}/{cmax} — {reasoning}")
+    else:
+        print(f"[C] Score: {normalized:.2f}")
+
+    feedback = data.get("feedback")
+    if feedback:
+        fb_display = feedback if len(feedback) <= 300 else feedback[:300] + "..."
+        print(f"[C] Feedback: {fb_display}")
+
+    # Print golden URLs if present in accumulators
+    golden_urls = (data.get("accumulators") or {}).get("golden_urls")
+    if golden_urls:
+        for url in golden_urls:
+            print(f"[C] Gold reference: {url}")
+
+
 # ---------------------------------------------------------------------------
 # Sync judge
 # ---------------------------------------------------------------------------
@@ -517,5 +675,6 @@ class SyncJudge:
             task_id=task_id,
         )
 
+        _print_judge_call_start(rubric, images, agentic, model)
         response = self._client.request("POST", "/v1/judge/grade", json=body)
         return _parse_grade_response(response.json())

{fleet_python-0.2.112 → fleet_python-0.2.114/fleet_python.egg-info}/PKG-INFO

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

{fleet_python-0.2.112 → fleet_python-0.2.114}/pyproject.toml

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