cudag 0.3.10__py3-none-any.whl

cudag/modal_apps/upload.py

@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 Tylt LLC. All rights reserved.
+# CONFIDENTIAL AND PROPRIETARY. Unauthorized use, copying, or distribution
+# is strictly prohibited. For licensing inquiries: hello@claimhawk.app
+
+"""Compress a dataset run into chunks and upload to Modal with resume support.
+
+Pipeline: upload -> extract -> preprocess
+
+Usage:
+    uv run python -m modal_apps.upload              # Upload and auto-preprocess
+    uv run python -m modal_apps.upload --dry        # Upload only, no preprocess
+    uv run python -m modal_apps.upload --no-resume  # Force re-upload all chunks
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import shutil
+import subprocess
+import tarfile
+import tempfile
+from pathlib import Path
+
+# =============================================================================
+# CENTRALIZED CONFIGURATION
+# =============================================================================
+# Volume names are loaded from config/adapters.yaml via the SDK.
+# Users can customize these by editing the YAML file.
+
+try:
+    from sdk.modal_compat import get_volume_name
+    DEFAULT_VOLUME = get_volume_name("lora_training")
+except ImportError:
+    # Fallback when SDK not available
+    DEFAULT_VOLUME = "claimhawk-lora-training"
+DATASETS_ROOT = Path("datasets")
+CHUNK_SIZE_MB = 500  # Size of each chunk in MB
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description="Archive and upload a dataset run to Modal.")
+    parser.add_argument(
+        "run_dir",
+        type=Path,
+        nargs="?",
+        help="Dataset subdirectory under ./datasets to upload (defaults to newest run).",
+    )
+    parser.add_argument(
+        "--chunk-size",
+        type=int,
+        default=CHUNK_SIZE_MB,
+        help=f"Chunk size in MB (default: {CHUNK_SIZE_MB})",
+    )
+    parser.add_argument(
+        "--resume",
+        action="store_true",
+        default=True,
+        help="Resume a previously interrupted upload (default: True)",
+    )
+    parser.add_argument(
+        "--no-resume",
+        action="store_false",
+        dest="resume",
+        help="Disable resume and re-upload all chunks",
+    )
+    return parser.parse_args()
+
+
+def pick_latest_run() -> Path:
+    """Find the most recently modified dataset run directory."""
+    if not DATASETS_ROOT.exists():
+        raise SystemExit("datasets/ directory not found")
+    runs = [p for p in DATASETS_ROOT.iterdir() if p.is_dir()]
+    if not runs:
+        raise SystemExit("No dataset runs found under ./datasets")
+    return max(runs, key=lambda p: p.stat().st_mtime)
+
+
+def file_md5(path: Path) -> str:
+    """Calculate MD5 hash of a file."""
+    hasher = hashlib.md5()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            hasher.update(chunk)
+    return hasher.hexdigest()
+
+
+def create_archive(run_path: Path, temp_dir: Path) -> Path:
+    """Create a gzipped tarball of the dataset run."""
+    archive_path = temp_dir / f"{run_path.name}.tar.gz"
+    print(f"Creating archive {archive_path.name}...")
+    with tarfile.open(archive_path, "w:gz") as archive:
+        archive.add(run_path, arcname=run_path.name)
+    return archive_path
+
+
+def split_archive(archive_path: Path, chunk_size_mb: int) -> list[Path]:
+    """Split archive into chunks of specified size."""
+    chunk_size = chunk_size_mb * 1024 * 1024
+    archive_size = archive_path.stat().st_size
+    num_chunks = math.ceil(archive_size / chunk_size)
+
+    if num_chunks == 1:
+        return [archive_path]
+
+    print(f"Splitting into {num_chunks} chunks of {chunk_size_mb}MB each...")
+    chunks = []
+    with open(archive_path, "rb") as f:
+        for i in range(num_chunks):
+            chunk_path = archive_path.parent / f"{archive_path.stem}.part{i:03d}"
+            with open(chunk_path, "wb") as chunk_file:
+                chunk_file.write(f.read(chunk_size))
+            chunks.append(chunk_path)
+            print(f"  Created {chunk_path.name}")
+
+    return chunks
+
+
+def create_manifest(
+    ds_name: str, chunks: list[Path], temp_dir: Path
+) -> tuple[Path, dict[str, str]]:
+    """Create a manifest file with chunk info and checksums."""
+    chunks_dict: dict[str, dict[str, object]] = {}
+    checksums: dict[str, str] = {}
+
+    for chunk in chunks:
+        checksum = file_md5(chunk)
+        chunks_dict[chunk.name] = {
+            "size": chunk.stat().st_size,
+            "md5": checksum,
+        }
+        checksums[chunk.name] = checksum
+
+    manifest: dict[str, object] = {
+        "ds_name": ds_name,
+        "num_chunks": len(chunks),
+        "chunks": chunks_dict,
+    }
+
+    manifest_path = temp_dir / f"{ds_name}.manifest.json"
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2)
+
+    return manifest_path, checksums
+
+
+def get_uploaded_chunks(ds_name: str) -> dict[str, str]:
+    """Get list of already uploaded chunks from Modal volume."""
+    try:
+        result = subprocess.run(
+            ["uvx", "modal", "volume", "ls", DEFAULT_VOLUME, f"/datasets/{ds_name}_chunks/"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            return {}
+
+        # Parse the ls output to get filenames
+        uploaded = {}
+        for line in result.stdout.strip().split("\n"):
+            if line and not line.startswith("Directory"):
+                # Extract filename from ls output
+                parts = line.split()
+                if parts:
+                    filename = parts[-1]
+                    if filename.endswith(".md5"):
+                        continue
+                    # Try to get the checksum file
+                    md5_result = subprocess.run(
+                        [
+                            "uvx",
+                            "modal",
+                            "volume",
+                            "get",
+                            DEFAULT_VOLUME,
+                            f"/datasets/{ds_name}_chunks/{filename}.md5",
+                        ],
+                        capture_output=True,
+                        text=True,
+                        check=False,
+                    )
+                    if md5_result.returncode == 0:
+                        uploaded[filename] = md5_result.stdout.strip()
+        return uploaded
+    except Exception:
+        return {}
+
+
+def ensure_volume() -> None:
+    """Create the Modal volume if it doesn't exist."""
+    subprocess.run(["uvx", "modal", "volume", "create", DEFAULT_VOLUME], check=False)
+
+
+def upload_chunk(chunk_path: Path, ds_name: str, checksum: str) -> None:
+    """Upload a single chunk to the Modal volume."""
+    chunk_name = chunk_path.name
+    remote_path = f"/datasets/{ds_name}_chunks/{chunk_name}"
+
+    # Upload the chunk
+    subprocess.run(
+        [
+            "uvx",
+            "modal",
+            "volume",
+            "put",
+            "-f",
+            DEFAULT_VOLUME,
+            str(chunk_path),
+            remote_path,
+        ],
+        check=True,
+    )
+
+    # Upload checksum file for resume verification
+    checksum_path = chunk_path.parent / f"{chunk_name}.md5"
+    with open(checksum_path, "w") as f:
+        f.write(checksum)
+
+    subprocess.run(
+        [
+            "uvx",
+            "modal",
+            "volume",
+            "put",
+            "-f",
+            DEFAULT_VOLUME,
+            str(checksum_path),
+            f"{remote_path}.md5",
+        ],
+        check=True,
+    )
+
+
+def upload_manifest(manifest_path: Path, ds_name: str) -> None:
+    """Upload the manifest file."""
+    subprocess.run(
+        [
+            "uvx",
+            "modal",
+            "volume",
+            "put",
+            "-f",
+            DEFAULT_VOLUME,
+            str(manifest_path),
+            f"/datasets/{ds_name}_chunks/{manifest_path.name}",
+        ],
+        check=True,
+    )
+
+
+def main() -> None:
+    """Archive and upload a dataset run to Modal with chunking and resume support."""
+    args = parse_args()
+    run_path = args.run_dir if args.run_dir else pick_latest_run()
+    run_path = run_path.resolve()
+    if not run_path.exists():
+        raise SystemExit(f"Run path {run_path} does not exist")
+
+    ds_name = run_path.name
+    temp_dir = Path(tempfile.mkdtemp(prefix="dataset_archive_"))
+
+    try:
+        ensure_volume()
+
+        # Check for existing uploads if resuming
+        uploaded_chunks: dict[str, str] = {}
+        if args.resume:
+            print("Checking for previously uploaded chunks...")
+            uploaded_chunks = get_uploaded_chunks(ds_name)
+            if uploaded_chunks:
+                print(f"Found {len(uploaded_chunks)} previously uploaded chunks")
+
+        # Create archive
+        archive_path = create_archive(run_path, temp_dir)
+        total_size = archive_path.stat().st_size
+        print(f"Archive size: {total_size / (1024 * 1024):.1f}MB")
+
+        # Split into chunks
+        chunks = split_archive(archive_path, args.chunk_size)
+
+        # Create manifest with checksums
+        manifest_path, checksums = create_manifest(ds_name, chunks, temp_dir)
+
+        # Upload chunks (skip already uploaded ones with matching checksums)
+        for chunk in chunks:
+            chunk_name = chunk.name
+            expected_checksum = checksums[chunk_name]
+
+            if chunk_name in uploaded_chunks:
+                if uploaded_chunks[chunk_name] == expected_checksum:
+                    print(f"Skipping {chunk_name} (already uploaded, checksum matches)")
+                    continue
+                else:
+                    print(f"Re-uploading {chunk_name} (checksum mismatch)")
+
+            print(f"Uploading {chunk_name}...")
+            upload_chunk(chunk, ds_name, expected_checksum)
+
+        # Upload manifest
+        print("Uploading manifest...")
+        upload_manifest(manifest_path, ds_name)
+
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+    print(f"\nUploaded {ds_name} to Modal volume '{DEFAULT_VOLUME}' ({len(chunks)} chunks)")
+    # Output dataset name for shell script to use
+    print(f"DATASET_NAME={ds_name}")
+
+
+if __name__ == "__main__":
+    main()

cudag/prompts/SYSTEM_PROMPT.txt

@@ -0,0 +1,104 @@
+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. E.g. if you click on Firefox and a window doesn't open, try wait and taking another screenshot.
+* The screen's resolution is 1000x1000.
+* Whenever you intend to move the cursor to click on an element like an icon, you should consult a screenshot to determine the coordinates of the element before moving the cursor.
+* If you tried clicking on a program or link but it failed to load even after waiting, try adjusting your cursor position so that the tip of the cursor visually falls on the element that you want to click.
+* Make sure to click any buttons, links, icons, etc with the cursor tip in the center of the element. Don't click boxes on their edges unless asked.
+
+# 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>
+{
+  "type": "function",
+  "function": {
+    "name_for_human": "computer_use",
+    "name": "computer_use",
+    "description": "Perform computer actions",
+    "parameters": {
+      "properties": {
+        "action": {
+          "description": "* `key`: Performs key down presses on the arguments passed in order, then performs key releases in reverse order.\n* `type`: Type a string of text on the keyboard.\n* `mouse_move`: Move the cursor to a specified (x, y) pixel coordinate on the screen.\n* `left_click`: Left click at a specified (x, y) pixel coordinate on the screen.\n* `left_click_drag`: Click and drag the cursor to a specified (x, y) pixel coordinate on the screen.\n* `right_click`: Right click at a specified (x, y) pixel coordinate on the screen.\n* `middle_click`: Middle click at a specified (x, y) pixel coordinate on the screen.\n* `double_click`: Double-click the left mouse button at a specified (x, y) pixel coordinate on the screen.\n* `triple_click`: Triple-click the left mouse button at a specified (x, y) pixel coordinate on the screen.\n* `scroll`: Performs a scroll of the mouse scroll wheel.\n* `hscroll`: Performs a horizontal scroll.\n* `wait`: Wait specified seconds for the change to happen.\n* `terminate`: Terminate the current task and report its completion status.\n* `answer`: Answer a question.",
+          "enum": ["key", "type", "mouse_move", "left_click", "left_click_drag", "right_click", "middle_click", "double_click", "triple_click", "scroll", "hscroll", "wait", "terminate", "answer"],
+          "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."
+  }
+}
+{
+  "type": "function",
+  "function": {
+    "name_for_human": "get_bbox",
+    "name": "get_bbox",
+    "description": "Return the bounding box for a UI element",
+    "parameters": {
+      "properties": {
+        "bbox_2d": {
+          "description": "The bounding box coordinates [x1, y1, x2, y2] in resolution units (0-1000).",
+          "type": "array",
+          "items": {"type": "number"},
+          "minItems": 4,
+          "maxItems": 4
+        },
+        "label": {
+          "description": "The text label of the UI element.",
+          "type": "string"
+        }
+      },
+      "required": ["bbox_2d"],
+      "type": "object"
+    },
+    "args_format": "Format the arguments as a JSON object."
+  }
+}
+</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) One or more <tool_call>...</tool_call> blocks, one per line, each containing only the JSON.
+
+Rules:
+- Output exactly in the order: Action, <tool_call>(s).
+- Be brief: one sentence for Action.
+- Multiple tool calls can be output, one per line.
+- Do not output anything else outside those parts.
+- If finishing, use action=terminate in the tool call.

cudag/prompts/__init__.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2025 Tylt LLC. All rights reserved.
+# CONFIDENTIAL AND PROPRIETARY. Unauthorized use, copying, or distribution
+# is strictly prohibited. For licensing inquiries: hello@claimhawk.app
+
+"""System prompts and tool definitions for computer use training."""
+
+from cudag.prompts.system import (
+    CUA_SYSTEM_PROMPT,
+    SYSTEM_PROMPT,
+    get_system_prompt,
+)
+from cudag.prompts.tools import (
+    COMPUTER_USE_TOOL,
+    TOOL_ACTIONS,
+    BboxCall,
+    ToolCall,
+    format_tool_call,
+    parse_tool_call,
+    validate_tool_call,
+)
+
+__all__ = [
+    "COMPUTER_USE_TOOL",
+    "TOOL_ACTIONS",
+    "BboxCall",
+    "ToolCall",
+    "format_tool_call",
+    "parse_tool_call",
+    "validate_tool_call",
+    "CUA_SYSTEM_PROMPT",
+    "SYSTEM_PROMPT",
+    "get_system_prompt",
+]

cudag/prompts/system.py

@@ -0,0 +1,43 @@
+# Copyright (c) 2025 Tylt LLC. All rights reserved.
+# CONFIDENTIAL AND PROPRIETARY. Unauthorized use, copying, or distribution
+# is strictly prohibited. For licensing inquiries: hello@claimhawk.app
+
+"""System prompt for VLM training datasets.
+
+IMPORTANT: The system prompt is managed by the system-prompt project.
+Run `system-prompt/scripts/sync.sh` to update from the canonical source.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+# Load prompt from text file (managed by system-prompt project)
+_PROMPTS_DIR = Path(__file__).parent
+
+
+def _load_prompt() -> str:
+    """Load the system prompt from text file."""
+    filepath = _PROMPTS_DIR / "SYSTEM_PROMPT.txt"
+    if not filepath.exists():
+        raise FileNotFoundError(
+            f"System prompt file not found: {filepath}\n"
+            "Run system-prompt/scripts/sync.sh to generate prompt files."
+        )
+    return filepath.read_text().strip()
+
+
+# The canonical system prompt
+SYSTEM_PROMPT = _load_prompt()
+
+# Aliases for backward compatibility
+CUA_SYSTEM_PROMPT = SYSTEM_PROMPT
+
+
+def get_system_prompt() -> str:
+    """Get the system prompt.
+
+    Returns:
+        System prompt string
+    """
+    return SYSTEM_PROMPT