Fix stale image issue

Co-authored-by: Copilot <copilot@github.com>

Author: codeSamuraii

examples/image_thumbnails.py

@@ -18,6 +18,7 @@
 
 from io import BytesIO
 
+import uvicorn
 from fastapi import FastAPI, File, Form, UploadFile
 from fastapi.responses import Response
 from PIL import Image, ImageOps
@@ -73,3 +74,7 @@ async def make_thumbnail(
     blob = await file.read()
     jpeg = await thumbnail.run(blob, size=size)
     return Response(content=jpeg, media_type="image/jpeg")
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8080)

examples/pdf_report.py

@@ -24,6 +24,7 @@
 
 from io import BytesIO
 
+import uvicorn
 from fastapi import FastAPI
 from fastapi.responses import Response
 from pydantic import BaseModel
@@ -67,8 +68,11 @@ def render_report(title: str, rows: list[list[str | float]]) -> bytes:
 # --- FastAPI app ----------------------------------------------------------
 
 class ReportRequest(BaseModel):
-    title: str
-    rows: list[list[str | float]]
+    title: str = "Example Report"
+    rows: list[list[str | float]] = [
+        ["Revenue", 120000],
+        ["Costs", 80000],
+    ]
 
 
 app = FastAPI(title="pyfuse PDF service")
@@ -84,7 +88,12 @@ async def _shutdown() -> None:
     await pyfuse.disconnect()
 
 
-@app.post("/reports")
-async def make_report(req: ReportRequest) -> Response:
+@app.get("/reports")
+async def make_report() -> Response:
+    req = ReportRequest()
     pdf = await render_report.run(req.title, req.rows)
     return Response(content=pdf, media_type="application/pdf")
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8080)

pyfuse/core/task.py

@@ -1,20 +1,109 @@
 """Task dataclass: serializable envelope bundling a graph with arguments."""
 
+import base64
+import datetime as _dt
 import json
+import pathlib
 import uuid
+from decimal import Decimal
 from typing import Any, Self
 from dataclasses import field, dataclass
 
 from pyfuse.core.errors import SignatureError
 from pyfuse.core.signing import verify_signature, compute_signature
 
 _OBJECT_SENTINEL = "__pyfuse_obj__"
+_BYTES_SENTINEL = "__pyfuse_bytes__"
+_BUILTIN_SENTINEL = "__pyfuse_builtin__"
+
+
+def _encode_builtin(o: object) -> dict[str, Any] | None:
+    """Encode common stdlib types to a JSON-safe sentinel.
+
+    Returns ``None`` if *o* is not a recognised builtin -- the caller
+    falls back to object-state serialization.
+    """
+    # datetime is a subclass of date, so check it first.
+    if isinstance(o, _dt.datetime):
+        return {"type": "datetime", "value": o.isoformat()}
+    if isinstance(o, _dt.date):
+        return {"type": "date", "value": o.isoformat()}
+    if isinstance(o, _dt.time):
+        return {"type": "time", "value": o.isoformat()}
+    if isinstance(o, _dt.timedelta):
+        return {"type": "timedelta", "value": o.total_seconds()}
+    if isinstance(o, Decimal):
+        return {"type": "decimal", "value": str(o)}
+    if isinstance(o, uuid.UUID):
+        return {"type": "uuid", "value": o.hex}
+    if isinstance(o, complex):
+        return {"type": "complex", "value": [o.real, o.imag]}
+    if isinstance(o, (set, frozenset)):
+        kind = "frozenset" if isinstance(o, frozenset) else "set"
+        return {"type": kind, "value": list(o)}
+    if isinstance(o, pathlib.PurePath):
+        return {"type": "path", "value": str(o), "cls": type(o).__name__}
+    return None
+
+
+_PATH_CLASSES: dict[str, type[pathlib.PurePath]] = {
+    "PurePath": pathlib.PurePath,
+    "PurePosixPath": pathlib.PurePosixPath,
+    "PureWindowsPath": pathlib.PureWindowsPath,
+    "Path": pathlib.Path,
+    "PosixPath": pathlib.PurePosixPath,
+    "WindowsPath": pathlib.PureWindowsPath,
+}
+
+
+def _decode_builtin(info: dict[str, Any], namespace: dict[str, Any]) -> Any:
+    """Reverse :func:`_encode_builtin`."""
+    kind = info.get("type")
+    raw = info.get("value")
+    if kind == "datetime":
+        return _dt.datetime.fromisoformat(raw)
+    if kind == "date":
+        return _dt.date.fromisoformat(raw)
+    if kind == "time":
+        return _dt.time.fromisoformat(raw)
+    if kind == "timedelta":
+        return _dt.timedelta(seconds=raw)
+    if kind == "decimal":
+        return Decimal(raw)
+    if kind == "uuid":
+        return uuid.UUID(hex=raw)
+    if kind == "complex":
+        return complex(raw[0], raw[1])
+    if kind == "set":
+        return {_resolve(v, namespace) for v in raw}
+    if kind == "frozenset":
+        return frozenset(_resolve(v, namespace) for v in raw)
+    if kind == "path":
+        # Try to honour the original class; fall back to a sensible
+        # OS-portable default if the concrete subclass cannot be
+        # instantiated on this platform.
+        cls = _PATH_CLASSES.get(info.get("cls", ""), pathlib.PurePath)
+        try:
+            return cls(raw)
+        except (NotImplementedError, TypeError):
+            return pathlib.PurePath(raw)
+    raise ValueError(f"Unknown builtin sentinel type: {kind!r}")
 
 
 class _TaskEncoder(json.JSONEncoder):
     """JSON encoder that serializes arbitrary objects via class name + __dict__."""
 
     def default(self, o: object) -> Any:
+        if isinstance(o, (bytes, bytearray)):
+            return {
+                _BYTES_SENTINEL: {
+                    "data": base64.b64encode(bytes(o)).decode("ascii"),
+                    "type": type(o).__name__,
+                }
+            }
+        builtin = _encode_builtin(o)
+        if builtin is not None:
+            return {_BUILTIN_SENTINEL: builtin}
         if hasattr(o, "__dict__"):
             state = o.__dict__
         elif hasattr(type(o), "__slots__"):
@@ -62,6 +151,12 @@ def _resolve(value: Any, namespace: dict[str, Any]) -> Any:
         return value
     if len(value) == 1 and _OBJECT_SENTINEL in value:
         return _reconstruct_object(value[_OBJECT_SENTINEL], namespace)
+    if len(value) == 1 and _BYTES_SENTINEL in value:
+        info = value[_BYTES_SENTINEL]
+        raw = base64.b64decode(info["data"])
+        return bytearray(raw) if info.get("type") == "bytearray" else raw
+    if len(value) == 1 and _BUILTIN_SENTINEL in value:
+        return _decode_builtin(value[_BUILTIN_SENTINEL], namespace)
     return {k: _resolve(v, namespace) for k, v in value.items()}
 
 

pyfuse/worker/sandbox/docker.py

@@ -19,6 +19,7 @@
 import os
 import shutil
 import asyncio
+import hashlib
 import logging
 import contextlib
 from typing import Any
@@ -32,7 +33,28 @@
 logger = logging.getLogger(__name__)
 
 _DOCKERFILE_DIR = Path(__file__).resolve().parent  # contains Dockerfile + guest_agent.py
-_DEFAULT_IMAGE = "pyfuse-sandbox"
+_IMAGE_ASSETS = ("Dockerfile", "guest_agent.py", "_protocol.py")
+
+
+def _assets_digest() -> str:
+    """Short hash of the files baked into the sandbox image.
+
+    Used as the default image tag so a code change in the guest agent
+    or Dockerfile produces a fresh image instead of silently reusing a
+    stale one whose ``guest_agent.py`` no longer matches the host.
+    """
+    h = hashlib.sha256()
+    for name in _IMAGE_ASSETS:
+        path = _DOCKERFILE_DIR / name
+        if path.exists():
+            h.update(name.encode())
+            h.update(b"\0")
+            h.update(path.read_bytes())
+            h.update(b"\0")
+    return h.hexdigest()[:12]
+
+
+_DEFAULT_IMAGE = f"pyfuse-sandbox:{_assets_digest()}"
 _DEFAULT_CONTAINER = "pyfuse-sandbox"
 
 
@@ -156,6 +178,16 @@ async def start(self) -> None:
             await _build_image(self.image)
 
         container = self.container_name
+        if await _container_exists(container):
+            current_image = await _container_image(container)
+            if current_image != self.image:
+                logger.info(
+                    "Container '%s' was built from a different image (%s); "
+                    "recreating from '%s'",
+                    container, current_image or "<unknown>", self.image,
+                )
+                await _docker_wait("rm", "-f", container)
+
         if not await _container_running(container):
             if await _container_exists(container):
                 await _docker_wait("rm", "-f", container)
@@ -371,6 +403,17 @@ async def _container_running(name: str) -> bool:
     return rc == 0 and stdout.strip().lower() == "true"
 
 
+async def _container_image(name: str) -> str | None:
+    """Return the image (with tag) the container was created from, or None."""
+    rc, stdout, _ = await _docker_wait(
+        "inspect", "-f", "{{.Config.Image}}", name,
+    )
+    if rc != 0:
+        return None
+    image = stdout.strip()
+    return image or None
+
+
 async def _mapped_port(container: str, guest_port: int) -> int:
     rc, stdout, stderr = await _docker_wait("port", container, str(guest_port))
     if rc != 0: