temp save

src/cua_lite/data/interfaces/base.py

@@ -0,0 +1,130 @@
+import dataclasses
+import copy
+from typing import Callable, Any
+
+@dataclasses.dataclass
+class BaseDataInterface:
+
+    @staticmethod
+    def _process_batch_generic(
+        func: Callable[[dict[str, Any]], dict[str, Any]], 
+        batch: dict[str, list[Any]], 
+        output_col: str = "messages"
+    ) -> dict[str, list[Any]]:
+        """
+        Core reusable logic:
+        Process 'list of dicts' (Batch) -> Reconstruct 'Row' -> func -> Aggregate Results.
+        
+        Suitable for all 1-to-1 mapping operations.
+        """
+        # Determine batch size (by checking the length of an arbitrary column)
+        # Assumes batch is not empty and columns are aligned.
+        first_key = next(iter(batch))
+        batch_size = len(batch[first_key])
+        
+        results = []
+
+        for i in range(batch_size):
+            # 1. Dynamically reconstruct a Single Row: {'images': img, 'messages': msg ...}
+            #    This replaces manually constructing `single_row` in every function.
+            row = {key: batch[key][i] for key in batch}
+            
+            # 2. Call the processing function.
+            #    The function receives a single row and MUST return a dict (e.g., {'messages': ...})
+            processed_output = func(row)
+            
+            # 3. Extract result.
+            if output_col in processed_output:
+                results.append(processed_output[output_col])
+            else:
+                # Fallback or error handling if key is missing
+                raise KeyError(f"Function output missing expected key: {output_col}")
+            
+        return {output_col: results}
+
+    @staticmethod
+    def fill_images(row: dict[str, Any]) -> dict[str, Any]:
+        """
+        Processes a single row to inject images into messages.
+        """
+        # CRITICAL FIX: Use deepcopy. 
+        # Modifying 'row' in-place can corrupt the dataset cache or cause issues if data is reused.
+        messages = copy.deepcopy(row.get("messages", []))
+        images = row.get("images", [])
+
+        for msg in messages:
+            content = msg.get("content", [])
+            for item in content:
+                if item.get("type") == "image":
+                    idx = item.get("index", None)
+                    
+                    # Safety check: Ensure index is valid integer and within bounds
+                    if idx is None or not isinstance(idx, int):
+                        continue
+                    
+                    if 0 <= idx < len(images):
+                        # Replace in-place (on the copied object)
+                        item.pop("index", None)
+                        item.pop("text", None)
+                        item["image"] = images[idx]
+                    else:
+                        # Handle out-of-bounds error gracefully or log warning
+                        pass 
+
+        return {"messages": messages}
+    
+    @staticmethod
+    def fill_images_batch(batch: dict[str, list[Any]]) -> dict[str, list[Any]]:
+        return BaseDataInterface._process_batch_generic(
+            BaseDataInterface.fill_images, 
+            batch
+        )
+    
+    def planning_action_map(self, row: dict[str, Any]) -> dict[str, Any]:
+        # FIX: The generic helper expects a dict return, not a list.
+        return {"messages": row["messages"]}
+
+    def planning_action_map_batch(self, batch: dict[str, list[Any]]) -> dict[str, list[Any]]:
+        return BaseDataInterface._process_batch_generic(
+            self.planning_action_map, 
+            batch
+        )
+
+    def planning_context_map_messages(self, messages: list[dict]) -> list[dict]:
+        # Placeholder for actual logic
+        return messages
+
+    def planning_context_map_batch(self, batch: dict[str, list[Any]]) -> dict[str, list[Any]]:
+        """
+        Handles 1-to-N data expansion (Unrolling conversation history).
+        Note: This changes the number of rows.
+        """
+        messages_list = []
+        
+        # Note: If there are other columns in 'batch' (like 'images'), 
+        # they will be out of sync because we are expanding 'messages'.
+        # HF Datasets usually requires dropping other columns or expanding them manually here.
+        
+        for messages in batch["messages"]:
+            assistant_indices = [i for i, msg in enumerate(messages) if msg.get("role") == "assistant"]
+            for assistant_index in assistant_indices: 
+                # Slicing includes the assistant message
+                context = messages[:assistant_index+1]
+                processed_context = self.planning_context_map_messages(context)
+                messages_list.append(processed_context)
+                
+        return {"messages": messages_list}
+
+
+if __name__ == "__main__":
+    from datasets import load_from_disk
+    dataset = load_from_disk(".data/scalecua/ubuntu/shard-00000-of-00256")
+    breakpoint()
+    # dataset = dataset.map(
+    #     BaseDataInterface.fill_images_batch,
+    #     batched=True,
+    # )
+    dataset = dataset.map(
+        BaseDataInterface.fill_images,
+    )
+    breakpoint()

src/cua_lite/data/interfaces/qwen3_vl.py

@@ -0,0 +1,9 @@
+from cua_lite.data.interfaces.base import BaseDataInterface
+
+
+class Qwen3VLDataInterface(BaseDataInterface):
+
+    def planning_context_map_messages(self, messages: List[Dict]) -> List[Dict]:
+        # Placeholder for actual logic
+        return messages
+

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

@@ -19,9 +19,15 @@ cd ..
 
 ```shell
 # process 1/256 of the dataset
-python src/cua_data/preprocessing/opencua/opencua.py \
+python src/cua_lite/data/raw_ds_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" \
     --rank 0 --world_size 256 --overwrite
+
+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
 ```

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

@@ -0,0 +1,560 @@
+#!/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/utils/utils.py

@@ -0,0 +1,24 @@
+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"]