Upload download_CodeConvo.py

download_CodeConvo.py

@@ -0,0 +1,465 @@
+"""
+Script to examine and download CodeConvo dataset from Hugging Face
+Uses huggingface_hub library for inspection and download
+"""
+
+from huggingface_hub import (
+    list_repo_files,
+    hf_hub_download,
+    snapshot_download
+)
+from datasets import load_dataset
+import os
+import shutil
+import traceback
+from pathlib import Path
+import argparse
+
+def examine_repo_structure():
+    """Examine the structure of the dataset repository"""
+    print("\n" + "="*70)
+    print("EXAMINING REPOSITORY STRUCTURE")
+    print("="*70)
+    
+    repo_id = "jiebi/CodeConvo"
+    repo_type = "dataset"
+    
+    try:
+        # Get basic repo info
+        print("\n1. Repository Information:")
+        print("-" * 70)
+        print(f"Repo ID: {repo_id}")
+        print(f"Repo Type: {repo_type}")
+        
+        # List all files and folders
+        print("\n2. Files and Folders in Repository:")
+        print("-" * 70)
+        files = list_repo_files(repo_id=repo_id, repo_type=repo_type)
+        print(f"Total items: {len(files)}\n")
+        
+        # Organize by folder
+        folders = {}
+        for file_path in sorted(files):
+            if "/" in file_path:
+                folder = file_path.split("/")[0]
+                if folder not in folders:
+                    folders[folder] = []
+                folders[folder].append(file_path)
+            else:
+                if "root" not in folders:
+                    folders["root"] = []
+                folders["root"].append(file_path)
+        
+        # Display structure
+        for folder in sorted(folders.keys()):
+            print(f"\n📁 {folder}/")
+            for file_path in sorted(folders[folder])[:10]:  # Show first 10 files
+                size_marker = ""
+                if file_path.endswith((".parquet", ".jsonl", ".json", ".arrow")):
+                    size_marker = " [data file]"
+                print(f"   └─ {file_path}{size_marker}")
+            if len(folders[folder]) > 10:
+                print(f"   └─ ... and {len(folders[folder]) - 10} more files")
+        
+        print("\n" + "="*70)
+        return True
+        
+    except Exception as e:
+        print(f"\n✗ Error examining repository: {type(e).__name__}")
+        print(f"Message: {str(e)}")
+        traceback.print_exc()
+        return False
+
+
+def _filter_files_for_request(files, split=None, repo=None, direction=None):
+    """Filter repository files based on requested split/repo/direction."""
+    if not split:
+        return files
+
+    split = split.lower()
+
+    # --split train: download train/{direction}/...
+    if split == "train":
+        direction = direction or "c2i"
+        prefix = f"train/{direction}/"
+        return [f for f in files if f.startswith(prefix)]
+
+    # --split dev|test: download {repo}/{direction}/{split}/... and optional flat jsonl files
+    if split in ["dev", "test"]:
+        prefix = f"{repo}/{direction}/{split}/"
+        flat_jsonl_prefix = f"{repo}/{repo}.{direction}.{split}"
+        return [
+            f for f in files
+            if f.startswith(prefix) or f.startswith(flat_jsonl_prefix)
+        ]
+
+    return []
+
+
+def download_dataset(split=None, repo=None, direction=None):
+    """Download full dataset or a requested subset from Hugging Face.
+
+    Uses hf_hub_download() with force_download=True to ensure actual file download
+    (not symlinks or LFS pointers).
+    """
+    print("\n" + "="*70)
+    print("DOWNLOADING DATASET")
+    print("="*70)
+    
+    repo_id = "jiebi/CodeConvo"
+    local_dir = "./dataset/CodeConvo"
+    
+    if split:
+        scope = f"{split}_{repo or 'all'}_{direction or 'default'}"
+        completion_marker = os.path.join(local_dir, f".download_complete_{scope}")
+    else:
+        completion_marker = os.path.join(local_dir, ".download_complete")
+
+    # Backward compatibility for previous full download marker
+    if not split and os.path.exists(completion_marker):
+        print("\n✓ Dataset already downloaded (completion marker found)")
+        print(f"Location: {local_dir}")
+        return True
+    
+    # Create parent directory
+    os.makedirs("./dataset", exist_ok=True)
+    
+    if split:
+        print(f"\nDownloading subset to: {local_dir}")
+        print(f"Requested split={split}, repo={repo or 'N/A'}, direction={direction or 'N/A'}")
+    else:
+        print(f"\nDownloading entire dataset to: {local_dir}")
+    print("-" * 70)
+    
+    try:
+        # Step 1: List all files in the repository
+        print("\nStep 1: Listing all files in repository...")
+        files = list_repo_files(repo_id=repo_id, repo_type="dataset")
+        print(f"✓ Found {len(files)} files")
+        
+        # Filter out certain non-essential files
+        skip_patterns = ['.gitattributes', 'README.md', '.huggingface']
+        candidate_files = [f for f in files if not any(f.startswith(p) for p in skip_patterns)]
+        files_to_download = _filter_files_for_request(
+            candidate_files,
+            split=split,
+            repo=repo,
+            direction=direction,
+        )
+
+        if not files_to_download:
+            print("✗ No files matched the requested selection")
+            return False
+
+        print(f"  Will download {len(files_to_download)} files (after filtering)")
+        
+        # Step 2: Download each file individually with force_download=True
+        print("\nStep 2: Downloading files (this may take a while)...")
+        downloaded_count = 0
+        failed_files = []
+        
+        for i, file_path in enumerate(files_to_download, 1):
+            try:
+                # Show progress every 10 files
+                if i % 10 == 1 or i == len(files_to_download):
+                    print(f"  [{i}/{len(files_to_download)}] Downloading {file_path}...", end=" ", flush=True)
+                    show_status = True
+                else:
+                    show_status = False
+                
+                # Download file with force_download=True to ensure actual download
+                downloaded_path = hf_hub_download(
+                    repo_id=repo_id,
+                    filename=file_path,
+                    repo_type="dataset",
+                    cache_dir="./dataset/.cache",
+                    force_download=True,  # Force actual download, not symlinks
+                    force_filename=None
+                )
+                
+                # Create target directory structure
+                target_file = os.path.join(local_dir, file_path)
+                os.makedirs(os.path.dirname(target_file), exist_ok=True)
+                
+                # Copy downloaded file to target location
+                import shutil
+                shutil.copy2(downloaded_path, target_file)
+                
+                if show_status:
+                    file_size = os.path.getsize(target_file)
+                    size_str = f"{file_size/1024/1024:.1f}MB" if file_size > 1024*1024 else f"{file_size/1024:.1f}KB"
+                    print(f"✓ ({size_str})")
+                
+                downloaded_count += 1
+                
+            except Exception as file_error:
+                failed_files.append((file_path, str(file_error)[:50]))
+                if show_status:
+                    print(f"✗")
+        
+        print(f"\n✓ Downloaded {downloaded_count}/{len(files_to_download)} files")
+        
+        if failed_files:
+            print(f"⚠ {len(failed_files)} files failed to download:")
+            for fname, error in failed_files[:5]:
+                print(f"   - {fname}: {error}")
+            if len(failed_files) > 5:
+                print(f"   ... and {len(failed_files) - 5} more")
+        
+        # Step 3: Clean up cache directory
+        print("\nStep 3: Cleaning up cache...")
+        cache_dir = "./dataset/.cache"
+        if os.path.exists(cache_dir):
+            import shutil
+            shutil.rmtree(cache_dir)
+            print("✓ Cleaned up cache")
+        
+        # Step 4: Create completion marker
+        os.makedirs(local_dir, exist_ok=True)
+        with open(completion_marker, 'w') as f:
+            f.write("Download completed successfully\n")
+        print(f"✓ Created completion marker")
+        
+        return downloaded_count > 0
+        
+    except Exception as e:
+        print(f"\n✗ Download failed: {type(e).__name__}")
+        print(f"Message: {str(e)}")
+        traceback.print_exc()
+        return False
+
+
+def show_downloaded_structure():
+    """Display the structure of downloaded dataset"""
+    print("\n" + "="*70)
+    print("DOWNLOADED DATASET STRUCTURE")
+    print("="*70)
+    
+    local_dir = "./dataset/CodeConvo"
+    
+    if not os.path.exists(local_dir):
+        print(f"\n✗ Directory not found: {local_dir}")
+        return
+    
+    print(f"\nLocation: {local_dir}\n")
+    
+    def show_tree(path, prefix="", max_depth=3, current_depth=0):
+        if current_depth >= max_depth:
+            return
+        
+        try:
+            items = sorted(os.listdir(path))
+            dirs = [i for i in items if os.path.isdir(os.path.join(path, i))]
+            files = [i for i in items if os.path.isfile(os.path.join(path, i))]
+            
+            # Show directories
+            for i, dir_name in enumerate(dirs[:10]):
+                is_last = (i == len(dirs) - 1) and len(files) == 0
+                print(f"{prefix}{'└── ' if is_last else '├── '}{dir_name}/")
+                
+                new_prefix = prefix + ("    " if is_last else "│   ")
+                show_tree(os.path.join(path, dir_name), new_prefix, max_depth, current_depth + 1)
+            
+            if len(dirs) > 10:
+                print(f"{prefix}├── ... and {len(dirs) - 10} more directories")
+            
+            # Show files
+            for i, file_name in enumerate(files[:10]):
+                is_last = i == len(files) - 1
+                size = os.path.getsize(os.path.join(path, file_name))
+                size_str = f"({size/1024/1024:.1f}MB)" if size > 1024*1024 else f"({size/1024:.1f}KB)" if size > 1024 else f"({size}B)"
+                print(f"{prefix}{'└── ' if is_last else '├── '}{file_name} {size_str}")
+            
+            if len(files) > 10:
+                print(f"{prefix}└── ... and {len(files) - 10} more files")
+                
+        except PermissionError:
+            print(f"{prefix}[Permission Denied]")
+    
+    show_tree(local_dir)
+    print("\n" + "="*70)
+
+
+def resolve_data_path(base_dir, split=None, repo=None, direction=None):
+    """Resolve a dataset subfolder path based on repo/direction/split.
+
+    Args:
+        base_dir: Base dataset directory (e.g., ./dataset/CodeConvo)
+        split: Split name (e.g., train, dev, test)
+        repo: Repo folder name (e.g., ids, swe, kubernetes) - required for dev/test
+        direction: Retrieval direction (e.g., i2c, c2i) - defaults to c2i for train
+
+    Returns:
+        Resolved path string or None if invalid combination
+        
+    Examples:
+        - split=train, direction=c2i -> base_dir/train/c2i/
+        - split=train, direction=i2c -> base_dir/train/i2c/
+        - split=test, repo=kubernetes, direction=i2c -> base_dir/kubernetes/i2c/test
+    """
+    if not split:
+        return base_dir
+    
+    # For train split, path is train/{direction}
+    # Default direction to c2i for train
+    if split.lower() == "train":
+        direction = direction or "c2i"
+        path = os.path.join(base_dir, "train", direction)
+        return path
+    
+    # For dev/test splits, require repo and direction
+    # Path structure: {repo}/{direction}/{split}
+    if split.lower() in ["dev", "test"]:
+        if not repo or not direction:
+            return None
+        path = os.path.join(base_dir, repo, direction, split)
+        return path
+    
+    # Unknown split
+    return None
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Inspect CodeConvo structure and download full dataset or a selected subset.",
+        epilog="Examples:\n"
+               "  # Inspect structure only\n"
+               "  python download_CodeConvo.py --no-download\n\n"
+               "  # Download entire dataset\n"
+               "  python download_CodeConvo.py\n\n"
+               "  # Download only train files (defaults to c2i)\n"
+               "  python download_CodeConvo.py --split train\n"
+               "  python download_CodeConvo.py --split train --direction i2c\n\n"
+               "  # Download only dev/test files (requires --repo and --direction)\n"
+               "  python download_CodeConvo.py --split test --repo kubernetes --direction i2c\n",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument(
+        "--split",
+        type=str,
+        choices=["train", "dev", "test"],
+        help="Split name to resolve path for.",
+    )
+    parser.add_argument(
+        "--repo",
+        type=str,
+        help="Repo folder name (only valid for dev/test splits).",
+    )
+    parser.add_argument(
+        "--direction",
+        type=str,
+        choices=["i2c", "c2i"],
+        help="Retrieval direction. For train: defaults to c2i. For dev/test: required.",
+    )
+    parser.add_argument(
+        "--no-download",
+        action="store_true",
+        help="Skip downloading files and only inspect/resolve folder path.",
+    )
+    return parser.parse_args()
+
+
+def main():
+    """Main execution function"""
+    print("\n" + "="*70)
+    print("CODECONVO DATASET DOWNLOADER")
+    print("Repository: https://huggingface.co/datasets/jiebi/CodeConvo")
+    print("="*70)
+
+    args = parse_args()
+    base_dir = "./dataset/CodeConvo"
+    
+    # Validate arguments
+    if args.split == "train":
+        # For train split, only --direction is allowed (no --repo)
+        if args.repo:
+            print("\n✗ ERROR: --repo is not allowed when --split is 'train'")
+            print(f"\nUsage: python download_CodeConvo.py --split train [--direction <i2c|c2i>]")
+            print("Note: --direction defaults to 'c2i' if not specified")
+            return False
+    elif args.split in ["dev", "test"]:
+        # For dev/test splits, require both --repo and --direction
+        if not args.repo or not args.direction:
+            print("\n✗ ERROR: --repo and --direction are required when --split is 'dev' or 'test'")
+            print(f"\nUsage: python download_CodeConvo.py --split {args.split} --repo <repo_name> --direction <i2c|c2i>")
+            print("\nAvailable repos: ids, ids-supp, swe, kubernetes")
+            return False
+    
+    try:
+        # Step 1: Examine repository
+        if not examine_repo_structure():
+            print("\n⚠ Could not examine repository, but attempting download anyway...")
+
+        # Step 2: Download full dataset or requested subset (unless skipped)
+        if not args.no_download:
+            if not download_dataset(
+                split=args.split,
+                repo=args.repo,
+                direction=args.direction,
+            ):
+                print("\n✗ Download failed!")
+                return False
+
+        # Step 3: Show downloaded structure
+        show_downloaded_structure()
+
+        # Step 4: Resolve and validate specific folder path if split is specified
+        if args.split:
+            resolved_path = resolve_data_path(
+                base_dir, 
+                split=args.split, 
+                repo=args.repo, 
+                direction=args.direction
+            )
+            
+            print("\n" + "="*70)
+            print("RESOLVED FOLDER PATH")
+            print("="*70)
+            print(f"Requested split: {args.split}")
+            print(f"Requested repo: {args.repo or 'N/A'}")
+            print(f"Requested direction: {args.direction or 'N/A'}")
+            print(f"\nResolved path: {resolved_path}")
+            
+            if resolved_path and os.path.exists(resolved_path):
+                print(f"Status: ✓ EXISTS")
+                
+                # Show contents
+                try:
+                    items = os.listdir(resolved_path)
+                    print(f"\nContents ({len(items)} items):")
+                    for item in sorted(items)[:10]:
+                        item_path = os.path.join(resolved_path, item)
+                        if os.path.isdir(item_path):
+                            print(f"  📁 {item}/")
+                        else:
+                            size = os.path.getsize(item_path)
+                            size_str = f"{size/1024/1024:.1f}MB" if size > 1024*1024 else f"{size/1024:.1f}KB"
+                            print(f"  📄 {item} ({size_str})")
+                    if len(items) > 10:
+                        print(f"  ... and {len(items) - 10} more items")
+                except Exception as e:
+                    print(f"  (Could not list contents: {e})")
+            else:
+                print(f"Status: ✗ DOES NOT EXIST")
+                print(f"\nThe specified path was not found in the downloaded dataset.")
+                print(f"Please verify the dataset structure and your arguments.")
+        
+        print("\n" + "="*70)
+        print("✓ COMPLETED SUCCESSFULLY")
+        print("="*70)
+        return True
+        
+    except Exception as e:
+        print("\n" + "="*70)
+        print("✗ UNEXPECTED ERROR")
+        print("="*70)
+        print(f"\nException: {type(e).__name__}")
+        print(f"Message: {str(e)}")
+        print("\nFull traceback:")
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = main()
+    exit(0 if success else 1)