Hagon/test2

Overview

We are extremely delighted to release Multi-SWE-Bench. Multi-SWE-Bench aims to build a multi-language benchmark dataset containing real software engineering scenarios for evaluating the ability of LLM to solve real software engineering problems. The dataset supports multiple languages, currently including C, C++, Java, Javascript, Typescript, Rust, Go.

Data Instances Structure

An example of a Multi-SWE-bench datum is as follows:

org: (str) - Organization name identifier from Github.
repo: (str) - Repository name identifier from Github.
number: (int) - The PR number.
state: (str) - The PR state.
title: (str) - The PR title.
body: (str) - The PR body.
base: (dict) - The target branch information of the PR
resolved_issues: (list) - A json list of strings that represent issues that resolved by PR application.
fix_patch: (str) - A fix-file patch that was contributed by the solution PR.
test_patch: (str) - A test-file patch that was contributed by the solution PR.
fixed_tests: (dict) - A json dict of strings that represent tests that should be fixed after the PR application.
p2p_tests: (dict) - The tests that should pass before and after the PR application.
f2p_tests: (dict) - The tests resolved by the PR and tied to the issue resolution.
s2p_tests: (dict) - The tests that should skip before the PR application, and pass after the PR application.
n2p_tests: (dict) - The tests that did not exist before the PR application and tests that should be passed after the PR application.
run_result: (dict) - Overall run results, including number of tests passed, number of tests failed, etc.
test_patch_result: (dict) -  The result after the test patch was applied.
fix_patch_result: (dict) - The result after all the patches were applied.
instance_id: (str) - A formatted instance identifier, usually as org__repo_PR-number.

Usage

Load C++ related datasets:

from datasets import load_dataset

cpp_split = load_dataset("msb/msb, split='cpp')

Because huggingface's dataset library does not support complex nested structures, there are nested structures within these fields that have been serialized in the original dataset（huggingface）, and you'll have to deserialize these if you want to use this dataset.

SERIALIZATION_FIELDS = [
    'base', 'fixed tests', 'p2p_tests', 'f2p_tests',
    's2p_tests', 'n2p_tests', 'run_result',
    'test_patch_result', 'fix_patch_result'
]

sample

from datasets import load_dataset, config
import pandas as pd
import os
import json

# Constant definitions
# There are nested structures within these fields, which were serialized in the original dataset, and now these need to be deserialized
SERIALIZATION_FIELDS = [
    'base', 'fixed tests', 'p2p_tests', 'f2p_tests',
    's2p_tests', 'n2p_tests', 'run_result',
    'test_patch_result', 'fix_patch_result'
]
CACHE_DIR = 'D:/huggingface_cache'

def safe_deserialize(value):
    """Safely deserialize a JSON string"""
    try:
        if value in (None, ''):
            return None
        return json.loads(value)
    except (TypeError, json.JSONDecodeError) as e:
        print(f"Deserialization failed: {str(e)}")
        return value

def load_hf_dataset():
    """Load a HuggingFace dataset"""
    os.environ['HF_HOME'] = CACHE_DIR
    config.HF_DATASETS_CACHE = CACHE_DIR
    return load_dataset("Hagon/test2", split='cpp')

def analyze_dataset_structure(dataset):
    """Analyze and print the dataset structure"""
    print(f"Dataset size: {len(dataset)}")
    print("\nDataset structure analysis: " + "-" * 50)
    print("Field names and types:")
    for name, dtype in dataset.features.items():
        print(f"  {name}: {str(dtype)}")

def print_data_types(dataset, sample_count=3):
    """Print the data types of sample data"""
    print(f"\nData types of the first {sample_count} samples:")
    for i in range(min(sample_count, len(dataset))):
        print(f"\nSample {i}:")
        for key, value in dataset[i].items():
            print(f"  {key}: {type(value).__name__} ({len(str(value))} chars)")

def analyze_serialization(dataset, sample_count=3):
    """Analyze the deserialization results of fields"""
    print("\nDeserialization result analysis: " + "-" * 50)
    for i in range(min(sample_count, len(dataset))):
        print(f"\nSample {i}:")
        item = dataset[i]
        for key in SERIALIZATION_FIELDS:
            safe_key = key.replace(' ', '_')
            raw_value = item.get(safe_key)
            deserialized = safe_deserialize(raw_value)
            
            print(f"Field [{key}]:")
            print(f"  Original type: {type(raw_value).__name__}")
            print(f"  Deserialized type: {type(deserialized).__name__ if deserialized else 'None'}")
            
            if isinstance(deserialized, dict):
                sample = dict(list(deserialized.items())[:2])
                print(f"  Sample content: {str(sample)[:200]}...")
            elif deserialized:
                print(f"  Content preview: {str(deserialized)[:200]}...")
            else:
                print("  Empty/Invalid data")

def main():
    """Main function entry"""
    dataset = load_hf_dataset()
    # analyze_dataset_structure(dataset)
    # print_data_types(dataset)
    analyze_serialization(dataset)

if __name__ == "__main__":
    main()

Citation

If you found SWE-bench or our Multi-SWE-bench helpful for your work, please cite as follows:

@misc{zan2025multiswebench,
      title={Multi-SWE-bench: A Multilingual Benchmark for Issue Resolving}, 
      author={Xxx},
      year={2025},
      eprint={2503.17315},
      archivePrefix={arXiv},
      primaryClass={cs.SE},
      url={xxx}, 
}