Move logging logic into logging_utils.py

Extracts log_inference and its _readme_from_features helper out of
app.py into a dedicated module, keeping app.py focused on the Gradio
UI and inference pipeline.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app.py

@@ -10,8 +10,8 @@ import base64
 import json
 import html as html_lib
 from io import BytesIO
-from datetime import datetime, timezone
 from PIL import Image
+from logging_utils import log_inference
 
 MAX_SEED = np.iinfo(np.int32).max
 LANCZOS = getattr(Image, "Resampling", Image).LANCZOS
@@ -48,9 +48,6 @@ print("Using default attention processor (FA3 skipped for ZeroGPU GPU-arch compa
 
 print("torch.compile skipped: lazy Triton kernel compilation inside @spaces.GPU always exceeds ZeroGPU's task timeout.")
 
-HF_TOKEN     = os.environ.get("HF_TOKEN")
-DATASET_REPO = os.environ.get("LOG_DATASET_REPO")
-
 EXAMPLES_CONFIG = [
     {
         "images": ["examples/1.jpg"],
@@ -188,135 +185,6 @@ def update_dimensions_on_upload(image):
     return (nw // 8) * 8, (nh // 8) * 8
 
 
-def _readme_from_features(feats):
-    lines = ["---", "configs:", "- config_name: default",
-             "  data_files:", "  - split: train",
-             "    path: data/*.parquet", "  features:"]
-    for name, f in feats.items():
-        lines.append(f"  - name: {name}")
-        if f.get("_type") == "Image":
-            lines.append("    dtype: image")
-        elif f.get("_type") == "Sequence" and f.get("feature", {}).get("_type") == "Image":
-            lines.append("    sequence: image")
-        else:
-            lines.append(f"    dtype: {f.get('dtype', 'string')}")
-    lines.append("---")
-    return "\n".join(lines) + "\n"
-
-
-def log_inference(pil_inputs, output_pil, prompt, seed, steps, guidance_scale,
-                  input_width, input_height, duration_seconds, success, error_message=""):
-    if not HF_TOKEN or not DATASET_REPO:
-        return
-    try:
-        import tempfile, json as _json
-        import pyarrow as pa
-        import pyarrow.parquet as pq
-        from huggingface_hub import HfApi, hf_hub_download
-
-        # Image columns need Arrow struct {bytes: binary, path: utf8} plus
-        # a 'huggingface' schema metadata key for the HF viewer to render them.
-        img_struct = pa.struct([("bytes", pa.binary()), ("path", pa.string())])
-        hf_meta = _json.dumps({"info": {"features": {
-            "timestamp":        {"dtype": "string",  "_type": "Value"},
-            "prompt":           {"dtype": "string",  "_type": "Value"},
-            "seed":             {"dtype": "int32",   "_type": "Value"},
-            "steps":            {"dtype": "int32",   "_type": "Value"},
-            "guidance_scale":   {"dtype": "float32", "_type": "Value"},
-            "input_images":     {"feature": {"_type": "Image"}, "_type": "Sequence"},
-            "output_image":     {"_type": "Image"},
-            "duration_seconds": {"dtype": "float32", "_type": "Value"},
-            "input_width":      {"dtype": "int32",   "_type": "Value"},
-            "input_height":     {"dtype": "int32",   "_type": "Value"},
-            "success":          {"dtype": "bool",    "_type": "Value"},
-            "error_message":    {"dtype": "string",  "_type": "Value"},
-        }}}).encode()
-        schema = pa.schema([
-            ("timestamp",        pa.string()),
-            ("prompt",           pa.string()),
-            ("seed",             pa.int32()),
-            ("steps",            pa.int32()),
-            ("guidance_scale",   pa.float32()),
-            ("input_images",     pa.list_(img_struct)),
-            ("output_image",     img_struct),
-            ("duration_seconds", pa.float32()),
-            ("input_width",      pa.int32()),
-            ("input_height",     pa.int32()),
-            ("success",          pa.bool_()),
-            ("error_message",    pa.string()),
-        ], metadata={b"huggingface": hf_meta})
-
-        def _to_jpeg(img, quality=85):
-            if img is None:
-                return None
-            buf = BytesIO()
-            img.convert("RGB").save(buf, format="JPEG", quality=quality)
-            return buf.getvalue()
-
-        def _img(b):
-            return {"bytes": b, "path": None}
-
-        input_jpegs = [_to_jpeg(img) for img in pil_inputs]
-        output_jpeg = _to_jpeg(output_pil)
-
-        new_table = pa.table({
-            "timestamp":        pa.array([datetime.now(timezone.utc).isoformat()], type=pa.string()),
-            "prompt":           pa.array([prompt],              type=pa.string()),
-            "seed":             pa.array([int(seed)],           type=pa.int32()),
-            "steps":            pa.array([int(steps)],          type=pa.int32()),
-            "guidance_scale":   pa.array([float(guidance_scale)], type=pa.float32()),
-            "input_images":     pa.array([[_img(b) for b in input_jpegs]], type=pa.list_(img_struct)),
-            "output_image":     pa.array([_img(output_jpeg) if output_jpeg else None], type=img_struct),
-            "duration_seconds": pa.array([float(duration_seconds)], type=pa.float32()),
-            "input_width":      pa.array([int(input_width)],   type=pa.int32()),
-            "input_height":     pa.array([int(input_height)],  type=pa.int32()),
-            "success":          pa.array([bool(success)],      type=pa.bool_()),
-            "error_message":    pa.array([str(error_message)], type=pa.string()),
-        }, schema=schema)
-        print(f"[log] built row — success={success}, inputs={len(input_jpegs)}")
-
-        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-        path_in_repo = f"data/{today}.parquet"
-        api = HfApi(token=HF_TOKEN)
-        api.create_repo(repo_id=DATASET_REPO, repo_type="dataset", private=True, exist_ok=True)
-
-        # Upload README.md once so the HF viewer knows the column types.
-        try:
-            hf_hub_download(repo_id=DATASET_REPO, filename="README.md",
-                            repo_type="dataset", token=HF_TOKEN)
-        except Exception:
-            readme = _readme_from_features(_json.loads(hf_meta)["info"]["features"])
-            api.upload_file(path_or_fileobj=readme.encode(), path_in_repo="README.md",
-                            repo_id=DATASET_REPO, repo_type="dataset")
-            print("[log] uploaded README.md with feature schema")
-
-        try:
-            local_path = hf_hub_download(
-                repo_id=DATASET_REPO, filename=path_in_repo,
-                repo_type="dataset", token=HF_TOKEN,
-            )
-            existing = pq.read_table(local_path)
-            combined = pa.concat_tables([existing, new_table])
-            combined = combined.replace_schema_metadata(schema.metadata)
-            print(f"[log] appending to existing {existing.num_rows} row(s)")
-        except Exception as dl_err:
-            print(f"[log] no existing file ({dl_err}), starting fresh")
-            combined = new_table
-
-        with tempfile.NamedTemporaryFile(suffix=".parquet", delete=False) as tmp:
-            tmp_path = tmp.name
-        pq.write_table(combined, tmp_path)
-        print(f"[log] uploading {path_in_repo} ({combined.num_rows} row(s), {os.path.getsize(tmp_path)//1024}KB)")
-        api.upload_file(
-            path_or_fileobj=tmp_path, path_in_repo=path_in_repo,
-            repo_id=DATASET_REPO, repo_type="dataset",
-        )
-        print(f"[log] upload done — {DATASET_REPO}/{path_in_repo}")
-    except Exception as log_err:
-        import traceback as _tb
-        print(f"[log] WARNING: {log_err}\n{_tb.format_exc()}")
-
-
 @spaces.GPU
 def infer(images_b64_json, prompt, seed, randomize_seed, guidance_scale, steps, progress=gr.Progress(track_tqdm=True)):
     import time, traceback

logging_utils.py

@@ -0,0 +1,135 @@
+import os
+from io import BytesIO
+from datetime import datetime, timezone
+
+HF_TOKEN     = os.environ.get("HF_TOKEN")
+DATASET_REPO = os.environ.get("LOG_DATASET_REPO")
+
+
+def _readme_from_features(feats):
+    lines = ["---", "configs:", "- config_name: default",
+             "  data_files:", "  - split: train",
+             "    path: data/*.parquet", "  features:"]
+    for name, f in feats.items():
+        lines.append(f"  - name: {name}")
+        if f.get("_type") == "Image":
+            lines.append("    dtype: image")
+        elif f.get("_type") == "Sequence" and f.get("feature", {}).get("_type") == "Image":
+            lines.append("    sequence: image")
+        else:
+            lines.append(f"    dtype: {f.get('dtype', 'string')}")
+    lines.append("---")
+    return "\n".join(lines) + "\n"
+
+
+def log_inference(pil_inputs, output_pil, prompt, seed, steps, guidance_scale,
+                  input_width, input_height, duration_seconds, success, error_message=""):
+    if not HF_TOKEN or not DATASET_REPO:
+        return
+    try:
+        import tempfile, json as _json
+        import pyarrow as pa
+        import pyarrow.parquet as pq
+        from huggingface_hub import HfApi, hf_hub_download
+
+        # Image columns need Arrow struct {bytes: binary, path: utf8} plus
+        # a 'huggingface' schema metadata key for the HF viewer to render them.
+        img_struct = pa.struct([("bytes", pa.binary()), ("path", pa.string())])
+        hf_meta = _json.dumps({"info": {"features": {
+            "timestamp":        {"dtype": "string",  "_type": "Value"},
+            "prompt":           {"dtype": "string",  "_type": "Value"},
+            "seed":             {"dtype": "int32",   "_type": "Value"},
+            "steps":            {"dtype": "int32",   "_type": "Value"},
+            "guidance_scale":   {"dtype": "float32", "_type": "Value"},
+            "input_images":     {"feature": {"_type": "Image"}, "_type": "Sequence"},
+            "output_image":     {"_type": "Image"},
+            "duration_seconds": {"dtype": "float32", "_type": "Value"},
+            "input_width":      {"dtype": "int32",   "_type": "Value"},
+            "input_height":     {"dtype": "int32",   "_type": "Value"},
+            "success":          {"dtype": "bool",    "_type": "Value"},
+            "error_message":    {"dtype": "string",  "_type": "Value"},
+        }}}).encode()
+        schema = pa.schema([
+            ("timestamp",        pa.string()),
+            ("prompt",           pa.string()),
+            ("seed",             pa.int32()),
+            ("steps",            pa.int32()),
+            ("guidance_scale",   pa.float32()),
+            ("input_images",     pa.list_(img_struct)),
+            ("output_image",     img_struct),
+            ("duration_seconds", pa.float32()),
+            ("input_width",      pa.int32()),
+            ("input_height",     pa.int32()),
+            ("success",          pa.bool_()),
+            ("error_message",    pa.string()),
+        ], metadata={b"huggingface": hf_meta})
+
+        def _to_jpeg(img, quality=85):
+            if img is None:
+                return None
+            buf = BytesIO()
+            img.convert("RGB").save(buf, format="JPEG", quality=quality)
+            return buf.getvalue()
+
+        def _img(b):
+            return {"bytes": b, "path": None}
+
+        input_jpegs = [_to_jpeg(img) for img in pil_inputs]
+        output_jpeg = _to_jpeg(output_pil)
+
+        new_table = pa.table({
+            "timestamp":        pa.array([datetime.now(timezone.utc).isoformat()], type=pa.string()),
+            "prompt":           pa.array([prompt],              type=pa.string()),
+            "seed":             pa.array([int(seed)],           type=pa.int32()),
+            "steps":            pa.array([int(steps)],          type=pa.int32()),
+            "guidance_scale":   pa.array([float(guidance_scale)], type=pa.float32()),
+            "input_images":     pa.array([[_img(b) for b in input_jpegs]], type=pa.list_(img_struct)),
+            "output_image":     pa.array([_img(output_jpeg) if output_jpeg else None], type=img_struct),
+            "duration_seconds": pa.array([float(duration_seconds)], type=pa.float32()),
+            "input_width":      pa.array([int(input_width)],   type=pa.int32()),
+            "input_height":     pa.array([int(input_height)],  type=pa.int32()),
+            "success":          pa.array([bool(success)],      type=pa.bool_()),
+            "error_message":    pa.array([str(error_message)], type=pa.string()),
+        }, schema=schema)
+        print(f"[log] built row — success={success}, inputs={len(input_jpegs)}")
+
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        path_in_repo = f"data/{today}.parquet"
+        api = HfApi(token=HF_TOKEN)
+        api.create_repo(repo_id=DATASET_REPO, repo_type="dataset", private=True, exist_ok=True)
+
+        # Upload README.md once so the HF viewer knows the column types.
+        try:
+            hf_hub_download(repo_id=DATASET_REPO, filename="README.md",
+                            repo_type="dataset", token=HF_TOKEN)
+        except Exception:
+            readme = _readme_from_features(_json.loads(hf_meta)["info"]["features"])
+            api.upload_file(path_or_fileobj=readme.encode(), path_in_repo="README.md",
+                            repo_id=DATASET_REPO, repo_type="dataset")
+            print("[log] uploaded README.md with feature schema")
+
+        try:
+            local_path = hf_hub_download(
+                repo_id=DATASET_REPO, filename=path_in_repo,
+                repo_type="dataset", token=HF_TOKEN,
+            )
+            existing = pq.read_table(local_path)
+            combined = pa.concat_tables([existing, new_table])
+            combined = combined.replace_schema_metadata(schema.metadata)
+            print(f"[log] appending to existing {existing.num_rows} row(s)")
+        except Exception as dl_err:
+            print(f"[log] no existing file ({dl_err}), starting fresh")
+            combined = new_table
+
+        with tempfile.NamedTemporaryFile(suffix=".parquet", delete=False) as tmp:
+            tmp_path = tmp.name
+        pq.write_table(combined, tmp_path)
+        print(f"[log] uploading {path_in_repo} ({combined.num_rows} row(s), {os.path.getsize(tmp_path)//1024}KB)")
+        api.upload_file(
+            path_or_fileobj=tmp_path, path_in_repo=path_in_repo,
+            repo_id=DATASET_REPO, repo_type="dataset",
+        )
+        print(f"[log] upload done — {DATASET_REPO}/{path_in_repo}")
+    except Exception as log_err:
+        import traceback as _tb
+        print(f"[log] WARNING: {log_err}\n{_tb.format_exc()}")