temp save

src/cua_lite/data/{raw_ds_preproc → preproc}/opencua/README.md

@@ -5,13 +5,13 @@ huggingface-cli download xlangai/AgentNet --repo-type dataset --local-dir .data/
 
 ```shell
 # 1. Navigate to the directory
-cd .data/huggingface/xlangai/AgentNet/{ubuntu_images,win_mac_images}
+cd .data/huggingface/xlangai/AgentNet/ubuntu_images
 
 # 2. Merge split volumes into a single archive (images-full.zip)
 zip -s 0 images.zip --out images-full.zip
 
 # 3. Extract the merged archive
-unzip images-full.zip -d ../{extracted_ubuntu_images,win_mac_images}
+unzip images-full.zip -d ../extracted_ubuntu_images
 
 # 4. (Optional) Return to the parent directory
 cd ..
@@ -19,15 +19,27 @@ cd ..
 
 ```shell
 # process 1/256 of the dataset
-python src/cua_lite/data/raw_ds_preproc/opencua/opencua.py \
+python src/cua_lite/data/preproc/opencua/opencua.py \
     --jsonl_path ".data/huggingface/xlangai/AgentNet/agentnet_ubuntu_5k.jsonl" \
     --extracted_images_dir ".data/huggingface/xlangai/AgentNet/extracted_ubuntu_images" \
-    --output_path ".data/scalecua/ubuntu" \
+    --output_path ".data/tmp/scalecua/ubuntu" \
     --rank 0 --world_size 256 --overwrite
+```
+
+```shell
+# unzip
+python src/cua_lite/data/unzip.py \
+    --input_path ".data/tmp/scalecua/ubuntu/shard-00000-of-00256" \
+    --output_path ".data/unzipped/scalecua/ubuntu/shard-00000-of-00256" \
+    --overwrite
+```
+
+```shell
+# convert to the format for infinite history
 
-python src/cua_lite/data/raw_ds_preproc/opencua/opencua_v2.py \
-    --jsonl_path ".data/huggingface/xlangai/AgentNet/agentnet_ubuntu_5k.jsonl" \
-    --extracted_images_dir ".data/huggingface/xlangai/AgentNet/extracted_ubuntu_images" \
-    --output_path ".data/scalecua/ubuntu_v2" \
-    --rank 0 --world_size 256 --overwrite
 ```
+
+```shell
+# convert to the format that qwen3 requires
+
+```

src/cua_lite/data/{raw_ds_preproc → preproc}/opencua/opencua.py

@@ -534,6 +534,7 @@ def main() -> None:
     features = build_features()
 
     if hasattr(Dataset, "from_generator"):
+        breakpoint()
         ds = Dataset.from_generator(
             iter_examples,
             gen_kwargs={
@@ -562,8 +563,6 @@ if __name__ == "__main__":
     main()
 
 
-
-
 """
 Attached file for GPT Pro
 - `agentnet_ubuntu.jsonl` (first 100 lines from `agentnet_ubuntu_5k.jsonl`)

src/cua_lite/data/raw_ds_preproc/opencua/opencua_v2.py

@@ -1,560 +0,0 @@
-#!/usr/bin/env python3
-"""Convert AgentNet JSONL trajectories into a HuggingFace dataset.
-
-Each JSONL line is expected to be a single task record with at least:
-  - instruction: str
-  - traj: list[step]
-    - step.image: str (image filename)
-    - step.value.thought: str
-    - step.value.action: str
-    - step.value.code: str (pyautogui/computer action code)
-
-Output dataset:
-  - messages: list[dict] in a multi-turn user/assistant format with interleaved images.
-
-Error handling (strict):
-  1) Raises if final action is not terminate.
-  2) Raises if any referenced image file is missing/unreadable.
-  3) Raises on any JSON/parsing/unexpected code formats.
-
-Requires:
-  pip install datasets pillow tyro
-
-Sharding (contiguous):
-  - If rank and world_size are specified (both not None), rank=0 processes the
-    first 1/world_size chunk of the dataset (by JSONL order), rank=1 the next
-    chunk, etc.
-  - Shards are saved to:
-      {output_path}/shard_{rank}of{world_size}
-"""
-
-from __future__ import annotations
-
-import ast
-import json
-import shutil
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Dict, Iterable, List, Optional, Tuple
-
-from PIL import Image as PILImage
-import tqdm
-import tyro
-
-
-# -----------------------------
-# Args
-# -----------------------------
-
-@dataclass
-class ScriptArguments:
-    jsonl_path: str = ".data/huggingface/xlangai/AgentNet/agentnet_ubuntu_5k.jsonl"
-    extracted_images_dir: str = ".data/huggingface/xlangai/AgentNet/extracted_ubuntu_images"
-    output_path: str = ".data/scalecua/ubuntu"
-    rank: Optional[int] = None
-    world_size: Optional[int] = None
-    overwrite: bool = False
-
-
-# -----------------------------
-# Qwen3-VL tool call formatting
-# -----------------------------
-
-def _make_computer_use_tool_call(arguments: Dict[str, Any]) -> Dict[str, Any]:
-    """Wrap a computer_use tool call in Qwen3-VL tool_call structure."""
-    if "action" not in arguments:
-        raise ValueError(f"computer_use arguments must include 'action'. Got: {arguments}")
-    return {
-        "type": "function",
-        "function": {
-            "name": "computer_use",
-            "arguments": arguments,
-        },
-    }
-
-
-# -----------------------------
-# AgentNet code parsing
-# -----------------------------
-
-class AgentNetCodeParseError(RuntimeError):
-    pass
-
-
-def _dotted_name(expr: ast.AST) -> str:
-    """Return dotted name for ast.Name / ast.Attribute chains, else empty string."""
-    if isinstance(expr, ast.Name):
-        return expr.id
-    if isinstance(expr, ast.Attribute):
-        base = _dotted_name(expr.value)
-        return f"{base}.{expr.attr}" if base else expr.attr
-    return ""
-
-
-def _literal_eval(node: ast.AST) -> Any:
-    try:
-        return ast.literal_eval(node)
-    except Exception as e:
-        raise AgentNetCodeParseError(f"Failed literal_eval on node={ast.dump(node)}") from e
-
-
-def _get_kw(call: ast.Call, name: str) -> Optional[ast.AST]:
-    for kw in call.keywords:
-        if kw.arg == name:
-            return kw.value
-    return None
-
-
-def _extract_xy(call: ast.Call) -> Tuple[float, float]:
-    """Extract x,y from a pyautogui-like call.
-
-    Supports keyword x=, y= (preferred), or positional (x, y).
-    """
-    x_node = _get_kw(call, "x")
-    y_node = _get_kw(call, "y")
-
-    if x_node is None and len(call.args) >= 1:
-        x_node = call.args[0]
-    if y_node is None and len(call.args) >= 2:
-        y_node = call.args[1]
-
-    if x_node is None or y_node is None:
-        raise AgentNetCodeParseError(
-            f"Expected x and y arguments, got args={len(call.args)} keywords={[kw.arg for kw in call.keywords]}"
-        )
-
-    x = float(_literal_eval(x_node))
-    y = float(_literal_eval(y_node))
-    return x, y
-
-
-def _norm01_to_0_1000(x: float, y: float) -> List[int]:
-    """Convert normalized [0,1] floats -> int [0,1000] with rounding."""
-    eps = 1e-6
-    if x < -eps or x > 1 + eps or y < -eps or y > 1 + eps:
-        raise AgentNetCodeParseError(f"Coordinates out of normalized range [0,1]: x={x}, y={y}")
-    xi = int(round(x * 1000))
-    yi = int(round(y * 1000))
-    xi = max(0, min(1000, xi))
-    yi = max(0, min(1000, yi))
-    return [xi, yi]
-
-
-def agentnet_code_to_qwen_tool_calls(code: str) -> List[Dict[str, Any]]:
-    """Convert AgentNet pyautogui/computer code string into Qwen3-VL computer_use tool calls."""
-    if not isinstance(code, str) or not code.strip():
-        raise AgentNetCodeParseError(f"Expected non-empty code string. Got: {code!r}")
-
-    try:
-        module = ast.parse(code)
-    except Exception as e:
-        raise AgentNetCodeParseError(f"ast.parse failed for code:\n{code}") from e
-
-    tool_calls: List[Dict[str, Any]] = []
-
-    for stmt in module.body:
-        if not isinstance(stmt, ast.Expr) or not isinstance(stmt.value, ast.Call):
-            raise AgentNetCodeParseError(
-                f"Unsupported statement type: {type(stmt).__name__}. Only expression calls are supported.\ncode=\n{code}"
-            )
-
-        call: ast.Call = stmt.value
-        fname = _dotted_name(call.func)
-
-        # ---- Mouse clicks ----
-        if fname == "pyautogui.click":
-            x, y = _extract_xy(call)
-            tool_calls.append(
-                _make_computer_use_tool_call({"action": "left_click", "coordinate": _norm01_to_0_1000(x, y)})
-            )
-            continue
-
-        if fname == "pyautogui.rightClick":
-            x, y = _extract_xy(call)
-            tool_calls.append(
-                _make_computer_use_tool_call({"action": "right_click", "coordinate": _norm01_to_0_1000(x, y)})
-            )
-            continue
-
-        if fname == "pyautogui.middleClick":
-            x, y = _extract_xy(call)
-            tool_calls.append(
-                _make_computer_use_tool_call({"action": "middle_click", "coordinate": _norm01_to_0_1000(x, y)})
-            )
-            continue
-
-        if fname == "pyautogui.doubleClick":
-            x, y = _extract_xy(call)
-            tool_calls.append(
-                _make_computer_use_tool_call({"action": "double_click", "coordinate": _norm01_to_0_1000(x, y)})
-            )
-            continue
-
-        if fname in {"pyautogui.tripleClick", "computer.tripleClick"}:
-            x, y = _extract_xy(call)
-            tool_calls.append(
-                _make_computer_use_tool_call({"action": "double_click", "coordinate": _norm01_to_0_1000(x, y)})
-            )
-            continue
-
-        # ---- Mouse movement / drag ----
-        if fname == "pyautogui.moveTo":
-            x, y = _extract_xy(call)
-            tool_calls.append(
-                _make_computer_use_tool_call({"action": "mouse_move", "coordinate": _norm01_to_0_1000(x, y)})
-            )
-            continue
-
-        if fname == "pyautogui.dragTo":
-            btn_node = _get_kw(call, "button")
-            btn = "left" if btn_node is None else str(_literal_eval(btn_node))
-            if btn != "left":
-                raise AgentNetCodeParseError(
-                    f"Only button='left' dragTo is supported. Got button={btn!r}.\ncode=\n{code}"
-                )
-            x, y = _extract_xy(call)
-            tool_calls.append(
-                _make_computer_use_tool_call({"action": "left_click_drag", "coordinate": _norm01_to_0_1000(x, y)})
-            )
-            continue
-
-        # ---- Scroll ----
-        if fname in {"pyautogui.scroll", "pyautogui.hscroll"}:
-            if len(call.args) < 1:
-                raise AgentNetCodeParseError(f"scroll/hscroll requires a pixels argument.\ncode=\n{code}")
-            pixels = int(_literal_eval(call.args[0]))
-            tool_calls.append(_make_computer_use_tool_call({"action": "scroll", "pixels": pixels}))
-            continue
-
-        # ---- Keyboard ----
-        if fname == "pyautogui.hotkey":
-            if len(call.args) != 1:
-                raise AgentNetCodeParseError(f"hotkey expected a single list argument.\ncode=\n{code}")
-            keys_val = _literal_eval(call.args[0])
-            if not isinstance(keys_val, (list, tuple)) or not keys_val:
-                raise AgentNetCodeParseError(f"hotkey arg must be a non-empty list/tuple. Got: {keys_val!r}")
-            keys = [str(k).lower() for k in keys_val]
-            tool_calls.append(_make_computer_use_tool_call({"action": "key", "keys": keys}))
-            continue
-
-        if fname == "pyautogui.press":
-            if len(call.args) != 1:
-                raise AgentNetCodeParseError(f"press expected a single key argument.\ncode=\n{code}")
-            key_val = _literal_eval(call.args[0])
-            if isinstance(key_val, (list, tuple)):
-                for k in key_val:
-                    tool_calls.append(_make_computer_use_tool_call({"action": "key", "keys": [str(k).lower()]}))
-            else:
-                tool_calls.append(_make_computer_use_tool_call({"action": "key", "keys": [str(key_val).lower()]}))
-            continue
-
-        if fname in {"pyautogui.write", "pyautogui.typewrite"}:
-            msg_node = _get_kw(call, "message")
-            if msg_node is None and len(call.args) == 1:
-                msg_node = call.args[0]
-            if msg_node is None:
-                raise AgentNetCodeParseError(f"write/typewrite requires message argument.\ncode=\n{code}")
-            text = str(_literal_eval(msg_node))
-            tool_calls.append(_make_computer_use_tool_call({"action": "type", "text": text}))
-            continue
-
-        # ---- Wait / Terminate ----
-        if fname == "computer.wait":
-            if len(call.args) == 0 and len(call.keywords) == 0:
-                t = 1.0
-            elif len(call.args) == 1 and len(call.keywords) == 0:
-                t = float(_literal_eval(call.args[0]))
-            else:
-                raise AgentNetCodeParseError(f"Unsupported wait signature.\ncode=\n{code}")
-            tool_calls.append(_make_computer_use_tool_call({"action": "wait", "time": t}))
-            continue
-
-        if fname == "computer.terminate":
-            status_node = _get_kw(call, "status")
-            if status_node is None:
-                raise AgentNetCodeParseError(f"terminate requires status='success'|'failure'.\ncode=\n{code}")
-            status = str(_literal_eval(status_node))
-            if status not in {"success", "failure"}:
-                raise AgentNetCodeParseError(f"Unsupported terminate status={status!r}.\ncode=\n{code}")
-            tool_calls.append(_make_computer_use_tool_call({"action": "terminate", "status": status}))
-            continue
-
-        raise AgentNetCodeParseError(f"Unsupported function call: {fname!r}.\ncode=\n{code}")
-
-    return tool_calls
-
-
-# -----------------------------
-# Trajectory -> dataset example
-# -----------------------------
-
-def _load_image_or_raise(path: Path) -> PILImage.Image:
-    if not path.exists():
-        raise FileNotFoundError(f"Missing image file: {path}")
-    try:
-        with PILImage.open(path) as im:
-            return im.convert("RGB").copy()
-    except Exception as e:
-        raise RuntimeError(f"Failed to open image: {path}") from e
-
-
-def record_to_example(record: Dict[str, Any], extracted_images_dir: Path) -> Dict[str, Any]:
-    """Convert one JSONL record into one dataset row with key: messages."""
-    instruction = record.get("instruction")
-    if not isinstance(instruction, str) or not instruction.strip():
-        raise ValueError(f"Missing/invalid 'instruction' in record. Keys={list(record.keys())}")
-
-    traj = record.get("traj")
-    if not isinstance(traj, list) or len(traj) == 0:
-        raise ValueError(f"Missing/invalid 'traj' in record. task_id={record.get('task_id')}")
-
-    images: List[PILImage.Image] = []
-    for i, step in enumerate(traj):
-        img_name = step.get("image")
-        if not isinstance(img_name, str) or not img_name:
-            raise ValueError(
-                f"Missing/invalid step.image at traj[{i}]. task_id={record.get('task_id')} step={step}"
-            )
-        img_path = extracted_images_dir / img_name
-        images.append(_load_image_or_raise(img_path))
-
-    messages: List[Dict[str, Any]] = []
-
-    messages.append(
-        {
-            "role": "user",
-            "content": [
-                {"type": "image", "image": images[0]},
-                {"type": "text", "text": instruction},
-            ],
-        }
-    )
-
-    for i, step in enumerate(traj):
-        value = step.get("value")
-        if not isinstance(value, dict):
-            raise ValueError(f"Missing/invalid step.value at traj[{i}] task_id={record.get('task_id')}")
-
-        thought = value.get("thought")
-        action_text = value.get("action")
-        code = value.get("code")
-
-        if not isinstance(thought, str):
-            raise ValueError(f"Missing/invalid value.thought at traj[{i}] task_id={record.get('task_id')}")
-        if not isinstance(action_text, str):
-            raise ValueError(f"Missing/invalid value.action at traj[{i}] task_id={record.get('task_id')}")
-        if not isinstance(code, str):
-            raise ValueError(f"Missing/invalid value.code at traj[{i}] task_id={record.get('task_id')}")
-
-        tool_calls = agentnet_code_to_qwen_tool_calls(code)
-
-        messages.append(
-            {
-                "role": "assistant",
-                "reasoning_content": thought,
-                "content": [{"type": "text", "text": action_text}],
-                "tool_calls": tool_calls,
-            }
-        )
-
-        if i != len(traj) - 1:
-            messages.append(
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "image", "image": images[i + 1]},
-                    ],
-                }
-            )
-
-    last_step_tool_calls = messages[-1].get("tool_calls")
-    if not isinstance(last_step_tool_calls, list) or len(last_step_tool_calls) == 0:
-        raise ValueError(f"Last assistant message has no tool_calls. task_id={record.get('task_id')}")
-
-    last_call = last_step_tool_calls[-1]
-    try:
-        last_action = last_call["function"]["arguments"]["action"]
-    except Exception:
-        raise ValueError(
-            f"Malformed tool_call structure in last step. task_id={record.get('task_id')} tool_call={last_call}"
-        )
-
-    if last_action != "terminate":
-        raise ValueError(
-            f"Final action is not terminate. task_id={record.get('task_id')} final_action={last_action!r}"
-        )
-
-    return {"messages": messages}
-
-
-def compute_shard_range(num_records: int, rank: int, world_size: int) -> Tuple[int, int]:
-    """Contiguous shard ranges.
-
-    Ensures:
-      - rank=0 gets the first chunk
-      - total coverage is exact (some ranks may get +1 if num_records % world_size != 0)
-    """
-    if world_size <= 0:
-        raise ValueError(f"Invalid world_size={world_size}")
-    if rank < 0 or rank >= world_size:
-        raise ValueError(f"Invalid rank={rank} for world_size={world_size}")
-
-    shard_size = num_records // world_size
-    remainder = num_records % world_size
-
-    start = rank * shard_size + min(rank, remainder)
-    end = start + shard_size + (1 if rank < remainder else 0)
-    return start, end
-
-
-def _count_nonempty_lines(jsonl_path: Path) -> int:
-    n = 0
-    with jsonl_path.open("r", encoding="utf-8") as f:
-        for line in f:
-            if line.strip():
-                n += 1
-    return n
-
-
-def iter_examples(
-    jsonl_path: Path,
-    extracted_images_dir: Path,
-    rank: Optional[int] = None,
-    world_size: Optional[int] = None,
-) -> Iterable[Dict[str, Any]]:
-    """Yield dataset rows from a JSONL file, optionally sharded contiguously by (rank, world_size)."""
-    if (rank is None) ^ (world_size is None):
-        raise ValueError("rank and world_size must be both specified or both None.")
-    if rank is not None:
-        if world_size is None:
-            raise ValueError("world_size must be provided if rank is provided.")
-        if world_size <= 0:
-            raise ValueError(f"Invalid world_size={world_size}")
-        if rank < 0 or rank >= world_size:
-            raise ValueError(f"Invalid rank={rank} for world_size={world_size}")
-
-    num_records = _count_nonempty_lines(jsonl_path)
-    if rank is not None:
-        start, end = compute_shard_range(num_records, rank, world_size)  # [start, end)
-    else:
-        start, end = 0, num_records
-
-    record_idx = 0  # counts non-empty JSONL lines
-    with jsonl_path.open("r", encoding="utf-8") as f:
-        for line_no, line in tqdm.tqdm(enumerate(f, start=1)):
-            line = line.strip()
-            if not line:
-                continue
-
-            if record_idx < start:
-                record_idx += 1
-                continue
-            if record_idx >= end:
-                break
-
-            try:
-                record = json.loads(line)
-            except Exception as e:
-                raise ValueError(f"JSON parse error at line {line_no} (record_idx={record_idx}) in {jsonl_path}") from e
-
-            if not isinstance(record, dict):
-                raise ValueError(f"Expected JSON object at line {line_no} (record_idx={record_idx})")
-
-            yield record_to_example(record, extracted_images_dir=extracted_images_dir)
-            record_idx += 1
-
-
-def build_features() -> Any:
-    """Define HuggingFace datasets Features for stable serialization."""
-    from datasets import Features, Image, Sequence, Value
-
-    return Features(
-        {
-            "messages": Sequence(
-                {
-                    "role": Value("string"),
-                    "content": Sequence(
-                        {
-                            "type": Value("string"),
-                            "text": Value("string"),
-                            "image": Image(),
-                        }
-                    ),
-                    "reasoning_content": Value("string"),
-                    "tool_calls": Sequence(
-                        {
-                            "type": Value("string"),
-                            "function": {
-                                "name": Value("string"),
-                                "arguments": {
-                                    "action": Value("string"),
-                                    "keys": Sequence(Value("string")),
-                                    "text": Value("string"),
-                                    "coordinate": Sequence(Value("int64")),
-                                    "pixels": Value("int64"),
-                                    "time": Value("float32"),
-                                    "status": Value("string"),
-                                },
-                            },
-                        }
-                    ),
-                }
-            ),
-        }
-    )
-
-
-def main() -> None:
-    args = tyro.cli(ScriptArguments)
-
-    jsonl_path = Path(args.jsonl_path)
-    extracted_images_dir = Path(args.extracted_images_dir)
-    output_path = Path(args.output_path)
-
-    if not jsonl_path.exists():
-        raise FileNotFoundError(f"jsonl_path not found: {jsonl_path}")
-    if not extracted_images_dir.exists():
-        raise FileNotFoundError(f"extracted_images_dir not found: {extracted_images_dir}")
-
-    # If sharded, save into a deterministic shard subdir so ranks don't clobber each other.
-    if args.rank is not None and args.world_size is not None:
-        output_path = output_path / f"shard-{args.rank:05d}-of-{args.world_size:05d}"
-
-    if output_path.exists():
-        if not args.overwrite:
-            raise FileExistsError(
-                f"output_path already exists: {output_path}. Use --overwrite to replace it."
-            )
-        shutil.rmtree(output_path)
-
-    from datasets import Dataset
-
-    features = build_features()
-
-    if hasattr(Dataset, "from_generator"):
-        ds = Dataset.from_generator(
-            iter_examples,
-            gen_kwargs={
-                "jsonl_path": jsonl_path,
-                "extracted_images_dir": extracted_images_dir,
-                "rank": args.rank,
-                "world_size": args.world_size,
-            },
-        )
-    else:
-        rows = list(
-            iter_examples(
-                jsonl_path=jsonl_path,
-                extracted_images_dir=extracted_images_dir,
-                rank=args.rank,
-                world_size=args.world_size,
-            )
-        )
-        ds = Dataset.from_list(rows)
-
-    ds.save_to_disk(str(output_path))
-    print(f"Saved dataset with {len(ds)} rows to: {output_path}")
-
-
-if __name__ == "__main__":
-    main()

src/cua_lite/data/unzip.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import tyro
+from datasets import load_from_disk
+from PIL import Image as PILImage
+
+# -----------------------------
+# Args
+# -----------------------------
+
+@dataclass
+class ScriptArguments:
+    input_path: str = ".data/tmp/scalecua/ubuntu/shard-00000-of-00256"
+    output_path: str = ".data/unzipped/scalecua/ubuntu/shard-00000-of-00256"
+    overwrite: bool = False
+
+
+# -----------------------------
+# Dataset Transformation
+# -----------------------------
+
+def _save_image(image: PILImage.Image, row_dir: Path, img_idx: int) -> str:
+    """Save PIL image to the specific row directory and return the absolute posix path."""
+    filename = f"{img_idx:03d}.png"
+    file_path = row_dir / filename
+    
+    image.save(file_path)
+    
+    return str(file_path.resolve())
+
+
+def process_row(
+    batch: Dict[str, Any], 
+    indices: List[int], 
+    output_data_dir: Path
+) -> Dict[str, Any]:
+    """
+    Process a batch of rows to:
+    1. Create a subdirectory for the row (e.g., data/00000000/).
+    2. Save images into that subdirectory.
+    3. Update message content:
+       - Images: point to saved path, remove 'index'.
+       - Text: remove 'index' (e.g. {'index': None, ...} -> { ... }).
+    """
+    out_messages_batch = []
+
+    for batch_idx, (row_images, row_messages) in enumerate(zip(batch["images"], batch["messages"])):
+        global_idx = indices[batch_idx]
+        
+        # 1. Prepare row-specific directory: output/data/00000000/
+        row_dir = output_data_dir / f"{global_idx:08d}"
+        row_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Cache saved paths for this row: map image_index -> absolute_path
+        saved_path_map: Dict[int, str] = {}
+        
+        for img_idx, image in enumerate(row_images):
+            # 2. Save image into the row directory
+            abs_path = _save_image(image, row_dir, img_idx)
+            saved_path_map[img_idx] = abs_path
+            
+        # 3. Rebuild messages
+        new_row_messages = []
+        
+        for msg in row_messages:
+            new_content = []
+            
+            raw_content = msg.get("content", [])
+            for item in raw_content:
+                item_type = item.get("type")
+                
+                if item_type == "image":
+                    # Handle Image: Transform structure and remove index implicitly
+                    idx_val = item.get("index")
+                    if idx_val is not None and idx_val in saved_path_map:
+                        new_content.append({
+                            "type": "image",
+                            "image": saved_path_map[idx_val]
+                        })
+                    else:
+                        raise ValueError(f"Image index {idx_val} not found in saved images for row {global_idx}")
+                else:
+                    # Handle Text/Other: Copy item and explicitly remove 'index'
+                    clean_item = item.copy()
+                    clean_item.pop("index", None)
+                    new_content.append(clean_item)
+            
+            # Dynamic Copy: Preserve ALL original keys and only overwrite 'content'
+            new_msg = msg.copy()
+            new_msg["content"] = new_content
+            
+            new_row_messages.append(new_msg)
+            
+        out_messages_batch.append(new_row_messages)
+
+    return {"messages": out_messages_batch}
+
+
+def main() -> None:
+    args = tyro.cli(ScriptArguments)
+    
+    input_path = Path(args.input_path)
+    output_path = Path(args.output_path)
+    output_data_dir = output_path / "data"
+
+    if not input_path.exists():
+        raise FileNotFoundError(f"input_path does not exist: {input_path}")
+        
+    if output_path.exists():
+        if args.overwrite:
+            shutil.rmtree(output_path)
+        else:
+            raise FileExistsError(f"output_path exists: {output_path}. Use --overwrite to replace.")
+
+    output_data_dir.mkdir(parents=True, exist_ok=True)
+    
+    print(f"Loading dataset from: {input_path}")
+    ds = load_from_disk(str(input_path))
+    
+    print(f"Processing {len(ds)} rows. Images will be saved to subdirectories in: {output_data_dir}")
+    
+    updated_ds = ds.map(
+        process_row,
+        fn_kwargs={"output_data_dir": output_data_dir},
+        batched=True,
+        with_indices=True,
+        desc="Extracting images and rewriting messages"
+    )
+    
+    if "images" in updated_ds.column_names:
+        updated_ds = updated_ds.remove_columns("images")
+
+    print(f"Saving modified dataset to: {output_path}")
+    updated_ds.save_to_disk(str(output_path))
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()
+
+
+"""
+# Args
+- `input_path` (str, default=".data/tmp/scalecua/ubuntu/shard-00000-of-00256")
+- `output_path` (str, default=".data/unzipped/scalecua/ubuntu/shard-00000-of-00256")
+
+# Task
+Write a Python script that loads the dataset from `input_path` and performs the following operations:
+
+1. **Save Images**: Extract images from the dataset and save them to `{output_path}/data`.
+2. **Transform Messages**: In the `messages` list, update the image entries to point to the saved files.
+   - **Change from**: 
+     `{'index': 0, 'text': None, 'type': 'image'}`
+   - **To**: 
+     `{'image': '/absolute/path/to/saved_image.png', 'type': 'image'}`
+3. **Cleanup**: Remove the `images` column from the dataset.
+4. **Save Dataset**: Save the modified dataset to `{output_path}`.
+
+# Example of Dataset Row before converstion (`ds[0]`)
+{
+    'images': [
+        <PIL.PngImagePlugin.PngImageFile image mode=RGB size=1920x1080>, 
+        <PIL.PngImagePlugin.PngImageFile image mode=RGB size=1920x1080>,
+        # ... more images
+    ], 
+    'messages': [
+        {
+            'role': 'user', 
+            'content': [
+                {'index': 0, 'text': None, 'type': 'image'}, 
+                {'index': None, 'text': 'Open the Pikachu picture...', 'type': 'text'}
+            ]
+        }, 
+        {
+            'role': 'assistant', 
+            'content': [{'index': None, 'text': 'Click on the GIMP...', 'type': 'text'}],
+            'reasoning_content': 'I need to start working...', 
+            'tool_calls': [
+                {'function': {'name': 'computer_use', 'arguments': {'action': 'left_click', ...}}}
+            ]
+        },
+        # ... subsequent turns
+    ]
+}
+
+# Example of Dataset Row after converstion (`ds[0]`)
+{
+    'images': [
+        <PIL.PngImagePlugin.PngImageFile image mode=RGB size=1920x1080>, 
+        <PIL.PngImagePlugin.PngImageFile image mode=RGB size=1920x1080>,
+        # ... more images
+    ], 
+    'messages': [
+        {
+            'role': 'user', 
+            'content': [
+                {'text': None, 'type': 'image'}, 
+                {'text': 'Open the Pikachu picture...', 'type': 'text'}
+            ]
+        }, 
+        {
+            'role': 'assistant', 
+            'content': [{'index': None, 'text': 'Click on the GIMP...', 'type': 'text'}],
+            'reasoning_content': 'I need to start working...', 
+            'tool_calls': [
+                {'function': {'name': 'computer_use', 'arguments': {'action': 'left_click', ...}}}
+            ]
+        },
+        # ... subsequent turns
+    ]
+}
+"""

src/cua_lite/data/utils.py

@@ -0,0 +1,21 @@
+# 1. 定义清洗函数（递归移除 None）
+def clean_nones(item):
+    """
+    递归移除字典或列表中值为 None 的键。
+    """
+    if isinstance(item, dict):
+        return {
+            k: clean_nones(v) 
+            for k, v in item.items() 
+            if v is not None
+        }
+    elif isinstance(item, list):
+        return [clean_nones(i) for i in item]
+    else:
+        return item
+
+# 2. 定义 Transform 函数（适配 Dataset 的 batch 格式）
+def transform_batch(batch):
+    # batch 是一个字典，例如 {'messages': [ [...], [...] ]}
+    # 我们需要对里面的每一个样本进行清洗
+    return {k: [clean_nones(item) for item in v] for k, v in batch.items()}

src/cua_lite/utils/utils.py

@@ -1,24 +0,0 @@
-def fill_images_into_messages(example: dict) -> dict:
-    """
-    Convert content items like:
-      {'type':'image','index':k,'text':None}
-    into:
-      {'type':'image','image': example['images'][k]}
-    (keeps other fields untouched)
-    """
-    images = example.get("images", [])
-    messages = example.get("messages", [])
-
-    for msg in messages:
-        content = msg.get("content", [])
-        for item in content:
-            if item.get("type") == "image":
-                idx = item.get("index", None)
-                if idx is None:
-                    continue
-                # replace in-place
-                item.pop("index", None)
-                item.pop("text", None)
-                item["image"] = images[idx]
-
-    return example["messages"]