temp save

src/cua_lite/data/interfaces/base.py

@@ -1,130 +1,60 @@
 import dataclasses
-import copy
 from typing import Callable, Any
 
+from cua_lite.data.utils import batch_proc
+
+
 @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 = []
+    # --- Grounding ---
+    # def process_grounding(self, row: dict[str, Any]) -> dict[str, Any]:
+    #     return row
 
-        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}
+    # def process_grounding_batch(self, batch: dict[str, list[Any]]) -> dict[str, list[Any]]:
+    #     return batch_proc(self.process_grounding, batch)
 
-    @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", [])
+    # --- Planning ---
+    def process_action(self, row: dict[str, Any]) -> dict[str, Any]:
+        return row
+
+    def process_action_batch(self, batch: dict[str, list[Any]]) -> dict[str, list[Any]]:
+        return batch_proc(self.process_action, batch)
 
-        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 
+    # --- Context ---
+    def process_context(self, row: dict[str, Any]) -> dict[str, Any]:
+        return row
+
+    def process_context_batch(
+        self, batch: dict[str, list[Any]]
+    ) -> dict[str, list[Any]]:
+        return batch_proc(self.process_context, batch)
 
-        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
-        )
+@dataclasses.dataclass
+class UnrolledContextDataInterface(BaseDataInterface):
 
-    def planning_context_map_messages(self, messages: list[dict]) -> list[dict]:
-        # Placeholder for actual logic
-        return messages
+    # useful for models support reasoning
 
-    def planning_context_map_batch(self, batch: dict[str, list[Any]]) -> dict[str, list[Any]]:
+    def process_context_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: 
+            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)
+                context = messages[: assistant_index + 1]
+                processed_context = self.process_context({"messages": context})[
+                    "messages"
+                ]
                 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()
+        return {"messages": messages_list}

src/cua_lite/data/interfaces/qwen3_vl.py

@@ -1,9 +1,250 @@
-from cua_lite.data.interfaces.base import BaseDataInterface
+import dataclasses
+import json
+import copy
+from typing import Callable, Any
 
+from cua_lite.data.interfaces.base import UnrolledContextDataInterface
 
-class Qwen3VLDataInterface(BaseDataInterface):
 
-    def planning_context_map_messages(self, messages: List[Dict]) -> List[Dict]:
-        # Placeholder for actual logic
-        return messages
+DESCRIPTION_PROMPT = """Use a mouse and keyboard to interact with a computer, and take screenshots.
+* This is an interface to a desktop GUI. You do not have access to a terminal or applications menu. You must click on desktop icons to start applications.
+* Some applications may take time to start or process actions, so you may need to wait and take successive screenshots to see the results of your actions. For example, if you click on Firefox and a window does not open, try waiting and then taking another screenshot.
+* The screen resolution is 1000x1000.
+* Whenever you intend to move the cursor to click on an element such as an icon, consult a screenshot first to determine the element’s coordinates before moving the cursor.
+* If you tried clicking on a program or link but it failed to load even after waiting, adjust your cursor position so that the tip of the cursor visually falls on the element you want to click.
+* Make sure to click any buttons, links, icons, or other elements with the cursor tip in the center of the element. Do not click on edges unless explicitly instructed.\
+"""
 
+ACTION_DESCRIPTION_PROMPT = """\
+* `key`: Performs key down presses on the arguments passed in order, then performs key releases in reverse order.
+* `type`: Type a string of text on the keyboard.
+* `mouse_move`: Move the cursor to a specified (x, y) pixel coordinate on the screen.
+* `left_click`: Click the left mouse button at a specified (x, y) pixel coordinate on the screen.
+* `left_click_drag`: Click and drag the cursor to a specified (x, y) pixel coordinate on the screen.
+* `right_click`: Click the right mouse button at a specified (x, y) pixel coordinate on the screen.
+* `middle_click`: Click the middle mouse button at a specified (x, y) pixel coordinate on the screen.
+* `double_click`: Double-click the left mouse button at a specified (x, y) pixel coordinate on the screen.
+* `triple_click`: Triple-click the left mouse button at a specified (x, y) pixel coordinate on the screen (simulated as double-click since it's the closest action).
+* `scroll`: Performs a scroll of the mouse scroll wheel.
+* `hscroll`: Performs a horizontal scroll (mapped to regular scroll).
+* `wait`: Wait specified seconds for the change to happen.
+* `terminate`: Terminate the current task and report its completion status.
+* `answer`: Answer a question.\
+"""
+
+TOOLS_DEF = {
+    "type": "function",
+    "function": {
+        "name_for_human": "computer_use",
+        "name": "computer_use",
+        "description": DESCRIPTION_PROMPT,
+        "parameters": {
+            "properties": {
+                "action": {
+                    "description": ACTION_DESCRIPTION_PROMPT,
+                    "enum": [
+                        "key",
+                        "type",
+                        "mouse_move",
+                        "left_click",
+                        "left_click_drag",
+                        "right_click",
+                        "middle_click",
+                        "double_click",
+                        "scroll",
+                        "wait",
+                        "terminate",
+                    ],
+                    "type": "string",
+                },
+                "keys": {
+                    "description": "Required only by `action=key`.",
+                    "type": "array",
+                },
+                "text": {
+                    "description": "Required only by `action=type`.",
+                    "type": "string",
+                },
+                "coordinate": {
+                    "description": "The x,y coordinates for mouse actions.",
+                    "type": "array",
+                },
+                "pixels": {"description": "The amount of scrolling.", "type": "number"},
+                "time": {"description": "The seconds to wait.", "type": "number"},
+                "status": {
+                    "description": "The status of the task.",
+                    "type": "string",
+                    "enum": ["success", "failure"],
+                },
+            },
+            "required": ["action"],
+            "type": "object",
+        },
+        "args_format": "Format the arguments as a JSON object.",
+    },
+}
+
+SYSTEM_PROMPT = (
+    """# Tools
+
+You may call one or more functions to assist with the user query.
+
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>
+"""
+    + json.dumps(TOOLS_DEF)
+    + """
+</tools>
+
+For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
+<tool_call>
+{"name": <function-name>, "arguments": <args-json-object>}
+</tool_call>
+
+# Response format
+
+Response format for every step:
+1) Action: a short imperative describing what to do in the UI.
+2) A single <tool_call>...</tool_call> block containing only the JSON: {"name": <function-name>, "arguments": <args-json-object>}.
+
+Rules:
+- Output exactly in the order: Action, <tool_call>.
+- Be brief: one sentence for Action.
+- Do not output anything else outside those parts.
+- If finishing, use action=terminate in the tool call."""
+)
+
+
+INSTRUCTION_PROMPT = """
+Please generate the next move according to the UI screenshot, instruction and previous actions.
+
+Instruction: {instruction}
+
+Previous actions:
+{previous_actions_str}"""
+
+
+@dataclasses.dataclass
+class Qwen3VLDataInterface(UnrolledContextDataInterface):
+
+    history_n: int = 4
+    add_system_prompt: bool = True
+
+    def process_context(self, row: dict[str, Any]) -> dict[str, Any]:
+        # 1. 基础拆分
+        messages = row["messages"]
+
+        # 2. 按 Step 分组 (User + Assistant)
+        steps = []
+        for i in range(0, len(messages), 2):
+            step = {
+                "user": messages[i],
+                "assistant": messages[i + 1] if i + 1 < len(messages) else None,
+            }
+            steps.append(step)
+
+        total_steps = len(steps)
+
+        # 3. 计算保留逻辑
+        steps_to_keep = self.history_n + 1
+
+        # ======== FIX 1: 不要在这里 return ========
+        # 如果总步数不够截断，就令 truncate_count=0（anchor=Step1），但仍然重写 INSTR_PROMPT
+        truncate_count = max(0, total_steps - steps_to_keep)
+        # =========================================
+
+        # 4. 提取 Step 1 的指令
+        step1_content = steps[0]["user"]["content"]
+        instruction_text = next(
+            item["text"] for item in step1_content if item.get("type") == "text"
+        )
+
+        # if "Previous actions" in instruction_text:
+        #     instruction_text = instruction_text.split("Previous actions")[0].strip()
+
+        # # 规范成 “纯 instruction 内容”
+        # if instruction_text.startswith("Instruction:"):
+        #     instruction_text = instruction_text[len("Instruction:"):].strip()
+
+        # 5. 生成历史摘要（被截断掉的那些步）
+        summary_lines = []
+        for i in range(truncate_count):
+            action = (
+                steps[i]["assistant"]["content"]
+                if isinstance(steps[i]["assistant"]["content"], str)
+                else steps[i]["assistant"]["content"][0]["text"]
+            )
+            summary_lines.append(f"Step {i+1}: {action}")
+
+        summary_block = "\n".join(summary_lines) if summary_lines else "None"
+
+        # 生成与 QwenAgent 一致的 INSTR_PROMPT
+        full_text_prompt = (
+            "\nPlease generate the next move according to the UI screenshot, instruction and previous actions.\n\n"
+            f"Instruction: {instruction_text}\n\n"
+            "Previous actions:\n"
+            f"{summary_block}"
+        )
+
+        # 6. 构建新消息列表
+        processed_messages = []
+        if self.add_system_prompt:
+            processed_messages.append(
+                {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]}
+            )
+
+        # --- Anchor Step (新起点) ---
+        anchor_step = steps[truncate_count]
+        new_anchor_user = copy.deepcopy(anchor_step["user"])
+
+        # 找到 User 消息里的 text 字段并修改，或者追加
+        text_item = next(
+            (item for item in new_anchor_user["content"] if item.get("type") == "text"),
+            None,
+        )
+        if text_item:
+            text_item["text"] = full_text_prompt
+        else:
+            new_anchor_user["content"].append(
+                {"type": "text", "text": full_text_prompt}
+            )
+
+        processed_messages.append(new_anchor_user)
+        if anchor_step["assistant"]:
+            processed_messages.append(anchor_step["assistant"])
+
+        # --- 追加剩余步骤 ---
+        for i in range(truncate_count + 1, total_steps):
+            # ======== FIX 2: 对齐 QwenAgent：非 anchor 的 user 只保留 image 部分 ========
+            u = copy.deepcopy(steps[i]["user"])
+            if isinstance(u.get("content"), list):
+                u["content"] = [it for it in u["content"] if it.get("type") != "text"]
+            processed_messages.append(u)
+            # ================================================================
+            if steps[i]["assistant"]:
+                processed_messages.append(steps[i]["assistant"])
+
+        return {"messages": processed_messages}
+
+
+if __name__ == "__main__":
+    from datasets import load_from_disk
+    from transformers import AutoProcessor
+    from cua_lite.data.utils import clean_nones
+
+    processor = AutoProcessor.from_pretrained(
+        "/mnt/lustrenew/mllm_aligned/shared/models/huggingface/Qwen/Qwen3-VL-2B-Thinking"
+    )
+
+    dataset = load_from_disk(".data/unzipped/scalecua/ubuntu/shard-00000-of-00256")
+    dataset.set_transform(clean_nones)
+
+    qwen3vl_interface = Qwen3VLDataInterface(history_n=4)
+    dataset_mapped = dataset.map(
+        qwen3vl_interface.process_context_batch, batched=True, batch_size=1000
+    )
+
+    inputs = processor.apply_chat_template(
+        dataset_mapped["messages"][0], return_dict=True
+    )
+    breakpoint()

src/cua_lite/data/preproc/README.md

@@ -0,0 +1,82 @@
+## Standardized dataset format
+Please see [`ZHZisZZ/test`](https://huggingface.co/datasets/ZHZisZZ/test) for an example.
+```
+# Dataset row format
+Each dataset row must contain exactly two keys: `images` and `messages`.
+
+1) images
+~~~~~~~~~
+A list of PIL images loaded from the extracted image directory:
+
+images = [
+    PIL(f"{image_0}"),
+    ...
+    PIL(f"{image_n}")
+]
+
+2) messages
+~~~~~~~~~~~
+A multi-turn chat transcript that alternates user/assistant turns.
+- The first user turn includes image index 0 AND the high-level instruction text.
+- Each subsequent user turn includes ONLY the next image index.
+- Each assistant turn includes:
+  - reasoning_content: reasoning that leads to the action.
+  - content: high-level description of the action.
+  - tool_calls: action taken in tool calling format.
+
+messages = [
+    # Initial user instruction + first image
+    {
+        "role": "user",
+        "content": [
+            {"type": "image", "index": 0},
+            {"type": "text", "text": f"{instruction}"},
+        ],
+    },
+
+    # Step 0 assistant response
+    {
+        "role": "assistant",
+        "reasoning_content": ..., # reasoning that leads to the action
+        "content": [{"type": "text", "text": ...}], # high-level description of the action
+        "tool_calls": [
+            {"type": "function", "function": {"name": "computer_use", "arguments": ...}}
+        ], # action taken in tool calling format.
+    },
+
+    # Step 1 user image
+    {
+        "role": "user",
+        "content": [
+            {"type": "image", "index": 1},
+        ],
+    },
+
+    # Step 1 assistant response
+    {
+        "role": "assistant",
+        "reasoning_content": ...,
+        "content": [{"type": "text", "text": ...}],
+        "tool_calls": [
+            {"type": "function", "function": {"name": "computer_use", "arguments": ...}}
+        ],
+    },
+
+    # ...
+    # Final step n
+    {
+        "role": "user",
+        "content": [
+            {"type": "image", "index": n},
+        ],
+    },
+    {
+        "role": "assistant",
+        "reasoning_content": "...",
+        "content": [{"type": "text", "text": "..."}],
+        "tool_calls": [
+            {"type": "function", "function": {"name": "computer_use", "arguments": ...}}
+        ],
+    },
+]
+```

src/cua_lite/data/preproc/opencua/README.md

@@ -1,5 +1,6 @@
 ## AgentNet Preprocessing
 
+Download AgentNet.
 ```shell
 huggingface-cli download xlangai/AgentNet --repo-type dataset --local-dir .data/huggingface/xlangai/AgentNet
 ```
@@ -18,7 +19,8 @@ unzip images-full.zip -d ../extracted_ubuntu_images
 cd ..
 ```
 
-TODO (zwc): Please scale it up and push the complete dataset to huggingface.
+Standardize AgentNet preprocessing using the Qwen3-VL action spaces. By saving images and text together, we can ensure proper visualization on Hugging Face.
+> TODO (zwc): Please scale it up and push the complete dataset to huggingface. The script is running slowly and needs to be sped up.
 ```shell
 # process 1/256 of the dataset
 python src/cua_lite/data/preproc/opencua/opencua.py \
@@ -31,20 +33,54 @@ python src/cua_lite/data/preproc/opencua/opencua.py \
 ## User Instruction
 > `.data/tmp/scalecua/ubuntu/shard-00000-of-00256` should be replaced with a remote huggingface dataset path after we have finished AgentNet Preprocessing and pushed the dataset to huggingface.
 
+Unzip the file to separate images and text. This prevents redundant image saving during the text preprocessing later on.
+> TODO (zwc): The script is running slowly and needs to be sped up.
 ```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
+# convert to default context unrolling messages format
+from datasets import load_from_disk
+from cua_lite.data.interfaces.base import UnrolledContextDataInterface
+from cua_lite.data.utils import clean_nones
 
-```
+dataset = load_from_disk(".data/unzipped/scalecua/ubuntu/shard-00000-of-00256")
+dataset.set_transform(clean_nones)
+
+unrolled_interface = UnrolledContextDataInterface()
+dataset_mapped = dataset.map(
+    unrolled_interface.process_context_batch, 
+    batched=True, 
+)
+``` -->
+
+Convert to qwen3 messages format.
+```python
+from datasets import load_from_disk
+from transformers import AutoProcessor
+
+from cua_lite.data.utils import clean_nones
+from cua_lite.data.interfaces.qwen3_vl import Qwen3VLDataInterface
+
+dataset = load_from_disk(".data/unzipped/scalecua/ubuntu/shard-00000-of-00256")
+dataset.set_transform(clean_nones)
+
+qwen3vl_interface = Qwen3VLDataInterface(history_n=4)
+dataset_mapped = dataset.map(
+    qwen3vl_interface.process_context_batch, 
+    batched=True, 
+)
 
-```shell
-# convert to the format that qwen3 requires
 
+processor = AutoProcessor.from_pretrained(
+    "/mnt/lustrenew/mllm_aligned/shared/models/huggingface/Qwen/Qwen3-VL-2B-Thinking"
+)
+inputs = processor.apply_chat_template(
+    dataset_mapped["messages"][0], return_dict=True
+)
+print(inputs)
 ```

src/cua_lite/data/preproc/opencua/opencua.py

@@ -47,10 +47,13 @@ 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"
+    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
@@ -61,10 +64,13 @@ class ScriptArguments:
 # 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}")
+        raise ValueError(
+            f"computer_use arguments must include 'action'. Got: {arguments}"
+        )
     return {
         "type": "function",
         "function": {
@@ -78,6 +84,7 @@ def _make_computer_use_tool_call(arguments: Dict[str, Any]) -> Dict[str, Any]:
 # AgentNet code parsing
 # -----------------------------
 
+
 class AgentNetCodeParseError(RuntimeError):
     pass
 
@@ -96,7 +103,9 @@ 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
+        raise AgentNetCodeParseError(
+            f"Failed literal_eval on node={ast.dump(node)}"
+        ) from e
 
 
 def _get_kw(call: ast.Call, name: str) -> Optional[ast.AST]:
@@ -133,7 +142,9 @@ 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}")
+        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))
@@ -166,35 +177,45 @@ def agentnet_code_to_qwen_tool_calls(code: str) -> List[Dict[str, Any]]:
         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)})
+                _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)})
+                _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)})
+                _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)})
+                _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)})
+                _make_computer_use_tool_call(
+                    {"action": "double_click", "coordinate": _norm01_to_0_1000(x, y)}
+                )
             )
             continue
 
@@ -202,7 +223,9 @@ def agentnet_code_to_qwen_tool_calls(code: str) -> List[Dict[str, Any]]:
         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)})
+                _make_computer_use_tool_call(
+                    {"action": "mouse_move", "coordinate": _norm01_to_0_1000(x, y)}
+                )
             )
             continue
 
@@ -215,38 +238,60 @@ def agentnet_code_to_qwen_tool_calls(code: str) -> List[Dict[str, Any]]:
                 )
             x, y = _extract_xy(call)
             tool_calls.append(
-                _make_computer_use_tool_call({"action": "left_click_drag", "coordinate": _norm01_to_0_1000(x, y)})
+                _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}")
+                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}))
+            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}")
+                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}")
+                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}))
+            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}")
+                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()]}))
+                    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()]}))
+                tool_calls.append(
+                    _make_computer_use_tool_call(
+                        {"action": "key", "keys": [str(key_val).lower()]}
+                    )
+                )
             continue
 
         if fname in {"pyautogui.write", "pyautogui.typewrite"}:
@@ -254,9 +299,13 @@ def agentnet_code_to_qwen_tool_calls(code: str) -> List[Dict[str, Any]]:
             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}")
+                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}))
+            tool_calls.append(
+                _make_computer_use_tool_call({"action": "type", "text": text})
+            )
             continue
 
         # ---- Wait / Terminate ----
@@ -266,21 +315,33 @@ def agentnet_code_to_qwen_tool_calls(code: str) -> List[Dict[str, Any]]:
             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}))
+                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}")
+                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}))
+                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}")
+        raise AgentNetCodeParseError(
+            f"Unsupported function call: {fname!r}.\ncode=\n{code}"
+        )
 
     return tool_calls
 
@@ -289,6 +350,7 @@ def agentnet_code_to_qwen_tool_calls(code: str) -> List[Dict[str, Any]]:
 # Trajectory -> dataset example
 # -----------------------------
 
+
 def _load_image_or_raise(path: Path) -> PILImage.Image:
     if not path.exists():
         raise FileNotFoundError(f"Missing image file: {path}")
@@ -299,15 +361,21 @@ def _load_image_or_raise(path: Path) -> PILImage.Image:
         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]:
+def record_to_example(
+    record: Dict[str, Any], extracted_images_dir: Path
+) -> Dict[str, Any]:
     """Convert one JSONL record into one dataset row with keys: images, 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())}")
+        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')}")
+        raise ValueError(
+            f"Missing/invalid 'traj' in record. task_id={record.get('task_id')}"
+        )
 
     images: List[PILImage.Image] = []
     for i, step in enumerate(traj):
@@ -334,18 +402,26 @@ def record_to_example(record: Dict[str, Any], extracted_images_dir: Path) -> Dic
     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')}")
+            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')}")
+            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')}")
+            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')}")
+            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)
 
@@ -370,7 +446,9 @@ def record_to_example(record: Dict[str, Any], extracted_images_dir: Path) -> Dic
 
     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')}")
+        raise ValueError(
+            f"Last assistant message has no tool_calls. task_id={record.get('task_id')}"
+        )
 
     last_call = last_step_tool_calls[-1]
     try:
@@ -388,7 +466,9 @@ def record_to_example(record: Dict[str, Any], extracted_images_dir: Path) -> Dic
     return {"images": images, "messages": messages}
 
 
-def compute_shard_range(num_records: int, rank: int, world_size: int) -> Tuple[int, int]:
+def compute_shard_range(
+    num_records: int, rank: int, world_size: int
+) -> Tuple[int, int]:
     """Contiguous shard ranges.
 
     Ensures:
@@ -456,10 +536,14 @@ def iter_examples(
             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
+                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})")
+                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
@@ -516,7 +600,9 @@ def main() -> None:
     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}")
+        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:
@@ -534,7 +620,6 @@ def main() -> None:
     features = build_features()
 
     if hasattr(Dataset, "from_generator"):
-        breakpoint()
         ds = Dataset.from_generator(
             iter_examples,
             gen_kwargs={

src/cua_lite/data/unzip.py

@@ -13,6 +13,7 @@ from PIL import Image as PILImage
 # Args
 # -----------------------------
 
+
 @dataclass
 class ScriptArguments:
     input_path: str = ".data/tmp/scalecua/ubuntu/shard-00000-of-00256"
@@ -24,20 +25,19 @@ class ScriptArguments:
 # 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
+    batch: Dict[str, Any], indices: List[int], output_data_dir: Path
 ) -> Dict[str, Any]:
     """
     Process a batch of rows to:
@@ -49,53 +49,56 @@ def process_row(
     """
     out_messages_batch = []
 
-    for batch_idx, (row_images, row_messages) in enumerate(zip(batch["images"], batch["messages"])):
+    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]
-                        })
+                        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}")
+                        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}
@@ -103,35 +106,39 @@ def process_row(
 
 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.")
+            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}")
-    
+
+    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"
+        desc="Extracting images and rewriting messages",
     )
-    
+
     if "images" in updated_ds.column_names:
         updated_ds = updated_ds.remove_columns("images")
 
@@ -190,16 +197,11 @@ Write a Python script that loads the dataset from `input_path` and performs the
 
 # 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'}, 
+                {'image': '{image_path}', 'text': None, 'type': 'image'}, 
                 {'text': 'Open the Pikachu picture...', 'type': 'text'}
             ]
         }, 

src/cua_lite/data/utils.py

@@ -1,21 +1,56 @@
-# 1. 定义清洗函数（递归移除 None）
+from collections import defaultdict
+from typing import Callable, Any
+
+
 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
-        }
+        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()}
+
+# # 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()}
+
+
+def batch_proc(
+    func: Callable[[dict[str, Any]], dict[str, Any]], batch: dict[str, list[Any]]
+) -> dict[str, list[Any]]:
+    """
+    Core reusable logic:
+    Process 'list of dicts' (Batch) -> Reconstruct 'Row' -> func -> Aggregate All Results.
+
+    Transforms a Columnar Batch input into a Columnar Batch output, preserving
+    all keys returned by the processing function.
+    """
+    # 1. Determine batch size
+    if not batch:
+        return {}
+
+    first_key = next(iter(batch))
+    batch_size = len(batch[first_key])
+
+    # Use defaultdict to automatically create lists for new keys
+    output_batch = defaultdict(list)
+
+    for i in range(batch_size):
+        # 2. Dynamically reconstruct a Single Row
+        row = {key: batch[key][i] for key in batch}
+
+        # 3. Call the processing function
+        #    Expected to return a dict, e.g., {'messages': ..., 'status': ..., 'meta': ...}
+        processed_row = func(row)
+
+        # 4. Aggregate ALL keys from the result
+        for key, value in processed_row.items():
+            output_batch[key].append(value)
+
+    return dict(output_batch)