fleet-python 0.2.113__tar.gz → 0.2.115__tar.gz

{fleet_python-0.2.113/fleet_python.egg-info → fleet_python-0.2.115}/PKG-INFO

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

{fleet_python-0.2.113 → fleet_python-0.2.115}/fleet/__init__.py

@@ -69,14 +69,14 @@ from .tasks import (
 from .types import VerifierFunction
 
 # Import judge data classes
-from .judge import Rubric, Criterion, Image, JudgeResult
+from .judge import Rubric, Criterion, File, Image, JudgeResult
 
 # Create a module-level env attribute for convenient access
 from . import env
 from . import global_client as _global_client
 from ._async import global_client as _async_global_client
 
-__version__ = "0.2.113"
+__version__ = "0.2.115"
 
 __all__ = [
     # Core classes
@@ -96,6 +96,7 @@ __all__ = [
     # Judge
     "Rubric",
     "Criterion",
+    "File",
     "Image",
     "JudgeResult",
     # Exceptions

{fleet_python-0.2.113 → fleet_python-0.2.115}/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.113"
+__version__ = "0.2.115"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.113 → fleet_python-0.2.115}/fleet/_async/base.py

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

{fleet_python-0.2.113 → fleet_python-0.2.115}/fleet/_async/judge.py

@@ -8,13 +8,17 @@ from typing import Dict, List, Optional, Union, TYPE_CHECKING
 # Import shared classes and helpers from the sync module
 from ..judge import (
     Criterion,
+    File,
     Image,
     JudgeResult,
     Rubric,
     _build_grade_request,
+    _collect_file_from_env_async,
     _collect_image_from_env_async,
+    _guess_file_media_type,
     _guess_media_type,
     _parse_grade_response,
+    _print_judge_call_start,
 )
 
 if TYPE_CHECKING:
@@ -24,6 +28,7 @@ if TYPE_CHECKING:
 __all__ = [
     "AsyncJudge",
     "Criterion",
+    "File",
     "Image",
     "JudgeResult",
     "Rubric",
@@ -51,6 +56,7 @@ class AsyncJudge:
         reference_claims: Optional[str] = None,
         conversation: Optional[List[dict]] = None,
         images: Optional[Dict[str, Image]] = None,
+        files: Optional[Dict[str, File]] = None,
         model: Optional[str] = None,
         provider: Optional[str] = None,
         agentic: bool = False,
@@ -71,6 +77,7 @@ class AsyncJudge:
             reference_claims: Reference analysis claims.
             conversation: Conversation history as list of message dicts.
             images: Named images for the judge (e.g., gold reference, agent output).
+            files: Named files for the judge (PDF, CSV, STEP, etc.).
             model: Override LLM model (server picks default if None).
             provider: Override LLM provider (server picks default if None).
             agentic: If True, the orchestrator collects artifacts from the instance.
@@ -100,6 +107,28 @@ class AsyncJudge:
                 else:
                     resolved_images[label] = img
 
+        # Resolve File.from_env files asynchronously before building request
+        resolved_files = files
+        if files and not agentic:
+            resolved_files = {}
+            for label, f in files.items():
+                if f.source == "env" and f._env is not None:
+                    b64 = await _collect_file_from_env_async(f._env, f.filename)
+                    if b64 is not None:
+                        resolved_files[label] = File.from_base64(
+                            b64,
+                            f.filename or "file",
+                            _guess_file_media_type(f.filename or "file"),
+                        )
+                    else:
+                        # Async collection failed — use collect source directly
+                        resolved_files[label] = File(
+                            source="collect",
+                            filename=f.filename,
+                        )
+                else:
+                    resolved_files[label] = f
+
         body = _build_grade_request(
             self._instance_id,
             rubric,
@@ -110,6 +139,7 @@ class AsyncJudge:
             reference_claims=reference_claims,
             conversation=conversation,
             images=resolved_images,
+            files=resolved_files,
             model=model,
             provider=provider,
             agentic=agentic,
@@ -117,5 +147,6 @@ class AsyncJudge:
             task_id=task_id,
         )
 
+        _print_judge_call_start(rubric, resolved_images, agentic, model, files=resolved_files)
         response = await self._client.request("POST", "/v1/judge/grade", json=body)
         return _parse_grade_response(response.json())

{fleet_python-0.2.113 → fleet_python-0.2.115}/fleet/base.py

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

{fleet_python-0.2.113 → fleet_python-0.2.115}/fleet/judge.py

@@ -38,6 +38,47 @@ def _guess_media_type(filename: str) -> str:
     }.get(ext, "image/png")
 
 
+def _guess_file_media_type(filename: str) -> str:
+    """Guess media type from filename extension for arbitrary files.
+
+    Broader than _guess_media_type — covers documents, CAD, data formats, etc.
+    """
+    ext = filename.lower().rsplit(".", 1)[-1] if "." in filename else ""
+    return {
+        # Images
+        "png": "image/png",
+        "jpg": "image/jpeg",
+        "jpeg": "image/jpeg",
+        "gif": "image/gif",
+        "webp": "image/webp",
+        "svg": "image/svg+xml",
+        # Documents
+        "pdf": "application/pdf",
+        "txt": "text/plain",
+        "md": "text/markdown",
+        "html": "text/html",
+        "htm": "text/html",
+        "csv": "text/csv",
+        "tsv": "text/tab-separated-values",
+        # Data
+        "json": "application/json",
+        "xml": "application/xml",
+        "yaml": "application/x-yaml",
+        "yml": "application/x-yaml",
+        # CAD / Engineering
+        "step": "application/step",
+        "stp": "application/step",
+        "stl": "model/stl",
+        "iges": "model/iges",
+        "igs": "model/iges",
+        "obj": "model/obj",
+        # Archives
+        "zip": "application/zip",
+        "gz": "application/gzip",
+        "tar": "application/x-tar",
+    }.get(ext, "application/octet-stream")
+
+
 @dataclass
 class Criterion:
     """A single rubric criterion for grading.
@@ -199,6 +240,99 @@ class Image:
         return d
 
 
+class File:
+    """Reference to an arbitrary file for LLM judge grading.
+
+    Supports any file type (PDF, CSV, STEP, STL, etc.) via the Anthropic
+    Files API. Use the static constructors to create instances:
+        File.s3("s3://bucket/key")                     - S3 URL, fetched server-side
+        File.from_base64(data, "part.step", "application/step") - Inline base64 data
+        File.from_env(env, "exported_part.step")        - Collect from environment
+    """
+
+    def __init__(
+        self,
+        *,
+        source: str,
+        url: Optional[str] = None,
+        data: Optional[str] = None,
+        filename: Optional[str] = None,
+        media_type: Optional[str] = None,
+        _env: Optional[Any] = None,
+    ):
+        self.source = source
+        self.url = url
+        self.data = data
+        self.filename = filename
+        self.media_type = media_type
+        self._env = _env
+
+    @staticmethod
+    def s3(url: str, media_type: Optional[str] = None) -> "File":
+        """Reference a file in S3. The orchestrator fetches it server-side."""
+        return File(source="s3", url=url, media_type=media_type)
+
+    @staticmethod
+    def from_base64(
+        data: str, filename: str, media_type: Optional[str] = None
+    ) -> "File":
+        """Inline base64 file data."""
+        return File(
+            source="base64",
+            data=data,
+            filename=filename,
+            media_type=media_type or _guess_file_media_type(filename),
+        )
+
+    @staticmethod
+    def from_env(env: Any, filename: str) -> "File":
+        """Collect a file from the environment.
+
+        In non-agentic mode, the SDK collects the file client-side (DB -> filesystem)
+        and sends base64 to the orchestrator.
+
+        In agentic mode, only the filename hint is sent and the orchestrator collects it.
+        """
+        return File(source="env", filename=filename, _env=env)
+
+    def serialize(self, *, label: Optional[str] = None, agentic: bool = False) -> dict:
+        """Serialize for the orchestrator API request body."""
+        d: dict
+        if self.source == "s3":
+            d = {"source": "s3", "url": self.url}
+            if self.media_type:
+                d["media_type"] = self.media_type
+        elif self.source == "base64":
+            d = {
+                "source": "base64",
+                "data": self.data,
+                "filename": self.filename,
+                "media_type": self.media_type or _guess_file_media_type(self.filename or "file"),
+            }
+        elif self.source == "collect":
+            d = {"source": "collect", "selector": self.filename}
+        elif self.source == "env":
+            if agentic:
+                d = {"source": "collect", "selector": self.filename}
+            else:
+                b64 = _collect_file_from_env(self._env, self.filename)
+                if b64 is None:
+                    d = {"source": "collect", "selector": self.filename}
+                else:
+                    d = {
+                        "source": "base64",
+                        "data": b64,
+                        "filename": self.filename,
+                        "media_type": _guess_file_media_type(self.filename or "file"),
+                    }
+        else:
+            raise ValueError(f"Unknown file source: {self.source}")
+
+        if label is not None:
+            d["label"] = label
+        return d
+
+
 class JudgeResult(float):
     """Float subclass that carries grading details.
 
@@ -412,6 +546,102 @@ async def _collect_image_from_env_async(env: Any, filename: str) -> Optional[str
     return None
 
 
+def _collect_file_from_env(env: Any, filename: str) -> Optional[str]:
+    """Collect a file from the environment using DB -> filesystem strategies.
+
+    Similar to _collect_image_from_env but skips notebook cell output strategy
+    (which is image-specific). Returns base64-encoded file 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(
+            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 file from DB: %s", best[0])
+            return base64.b64encode(candidates[best[0]]).decode()
+    except Exception as e:
+        logger.debug("DB file query failed: %s", e)
+
+    # Strategy 2: 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 file from filesystem: %s", fp)
+                    return base64.b64encode(f.read()).decode()
+        except Exception:
+            pass
+
+    return None
+
+
+async def _collect_file_from_env_async(env: Any, filename: str) -> Optional[str]:
+    """Async version of _collect_file_from_env.
+
+    Collects a file from an AsyncEnv using DB -> filesystem strategies.
+    Returns base64-encoded file 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 file from DB (async): %s", best[0])
+            return base64.b64encode(candidates[best[0]]).decode()
+    except Exception as e:
+        logger.debug("DB file query failed (async): %s", e)
+
+    # Strategy 2: 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 file from filesystem (async): %s", fp)
+                    return base64.b64encode(f.read()).decode()
+        except Exception:
+            pass
+
+    return None
+
+
 # ---------------------------------------------------------------------------
 # Accumulator printing (verifier protocol)
 # ---------------------------------------------------------------------------
@@ -441,6 +671,18 @@ 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 <<<")
+
+    agent_steps = acc.get("agent_steps")
+    if agent_steps:
+        print(">>> AGENT_STEPS >>>")
+        print(json.dumps(agent_steps))
+        print("<<< AGENT_STEPS <<<")
+
     timing = acc.get("timing")
     if timing:
         print(
@@ -455,6 +697,47 @@ 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],
+    files: Optional[Dict[str, "File"]] = None,
+) -> 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")
+
+    if files:
+        for label, f in files.items():
+            src = f.source
+            detail = ""
+            if f.url:
+                detail = f" url={f.url}"
+            elif f.filename:
+                detail = f" file={f.filename}"
+            if f.media_type:
+                detail += f" type={f.media_type}"
+            print(f"[C] File '{label}': source={src}{detail}")
+
+
 def _build_grade_request(
     instance_id: str,
     rubric: Union[str, Rubric],
@@ -466,6 +749,7 @@ def _build_grade_request(
     reference_claims: Optional[str] = None,
     conversation: Optional[List[dict]] = None,
     images: Optional[Dict[str, Image]] = None,
+    files: Optional[Dict[str, "File"]] = None,
     model: Optional[str] = None,
     provider: Optional[str] = None,
     agentic: bool = False,
@@ -520,16 +804,85 @@ def _build_grade_request(
             for label, img in images.items()
         ]
 
+    # Serialize files as labeled array
+    if files:
+        body["files"] = [
+            f.serialize(label=label, agentic=agentic)
+            for label, f in files.items()
+        ]
+
     return body
 
 
 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}")
+
+    # Print agentic judge steps if present
+    agent_steps = (data.get("accumulators") or {}).get("agent_steps")
+    if agent_steps:
+        print(f"[C] Agentic judge: {len(agent_steps)} steps")
+        for step in agent_steps:
+            stype = step.get("type", "?")
+            if stype == "mcp_connect":
+                print(f"[C]   MCP connected ({step.get('tools_available', '?')} tools)")
+            elif stype == "tool_call":
+                tool = step.get("tool", "?")
+                turn = step.get("turn", "?")
+                is_err = step.get("is_error", False)
+                result_preview = step.get("result", "")[:100]
+                status = "ERROR" if is_err else "ok"
+                print(f"[C]   Turn {turn}: {tool}() → {status}: {result_preview}")
+            elif stype == "final_response":
+                print(f"[C]   Turn {step.get('turn', '?')}: final response")
+            elif stype == "max_turns_reached":
+                print(f"[C]   Max turns reached ({step.get('turns_used', '?')})")
+
+
 # ---------------------------------------------------------------------------
 # Sync judge
 # ---------------------------------------------------------------------------
@@ -556,6 +909,7 @@ class SyncJudge:
         reference_claims: Optional[str] = None,
         conversation: Optional[List[dict]] = None,
         images: Optional[Dict[str, Image]] = None,
+        files: Optional[Dict[str, File]] = None,
         model: Optional[str] = None,
         provider: Optional[str] = None,
         agentic: bool = False,
@@ -575,7 +929,8 @@ class SyncJudge:
             context: Additional context for the judge.
             reference_claims: Reference analysis claims (folded into context).
             conversation: Conversation history as list of message dicts.
-            images: List of Image objects for the judge.
+            images: Named Image objects for the judge.
+            files: Named File objects for the judge (PDF, CSV, STEP, etc.).
             model: Override LLM model (server picks default if None).
             provider: Override LLM provider (server picks default if None).
             agentic: If True, the orchestrator collects artifacts from the instance.
@@ -592,6 +947,7 @@ class SyncJudge:
             reference_claims=reference_claims,
             conversation=conversation,
             images=images,
+            files=files,
             model=model,
             provider=provider,
             agentic=agentic,
@@ -599,5 +955,6 @@ class SyncJudge:
             task_id=task_id,
         )
 
+        _print_judge_call_start(rubric, images, agentic, model, files=files)
         response = self._client.request("POST", "/v1/judge/grade", json=body)
         return _parse_grade_response(response.json())

{fleet_python-0.2.113 → fleet_python-0.2.115/fleet_python.egg-info}/PKG-INFO

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

{fleet_python-0.2.113 → fleet_python-0.2.115}/pyproject.toml

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