--- license: apache-2.0 dataset_info: features: - name: org dtype: string - name: repo dtype: string - name: number dtype: int64 - name: state dtype: string - name: title dtype: string - name: body dtype: string - name: base dtype: string - name: resolved_issues list: - name: body dtype: string - name: number dtype: int64 - name: title dtype: string - name: fix_patch dtype: string - name: test_patch dtype: string - name: fixed_tests dtype: string - name: p2p_tests dtype: string - name: f2p_tests dtype: string - name: s2p_tests dtype: string - name: n2p_tests dtype: string - name: run_result dtype: string - name: test_patch_result dtype: string - name: fix_patch_result dtype: string - name: instance_id dtype: string splits: - name: c num_bytes: 27137585 num_examples: 128 - name: cpp num_bytes: 6406845 num_examples: 129 - name: go num_bytes: 171175811 num_examples: 428 - name: java num_bytes: 15981812 num_examples: 50 - name: javascript num_bytes: 505878991 num_examples: 356 - name: rust num_bytes: 40755929 num_examples: 239 - name: typescript num_bytes: 823172694 num_examples: 224 download_size: 375407095 dataset_size: 1590509667 configs: - config_name: default data_files: - split: c path: data/c-* - split: cpp path: data/cpp-* - split: go path: data/go-* - split: java path: data/java-* - split: javascript path: data/javascript-* - split: rust path: data/rust-* - split: typescript path: data/typescript-* --- # 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: ```python 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. ```python SERIALIZATION_FIELDS = [ 'base', 'fixed tests', 'p2p_tests', 'f2p_tests', 's2p_tests', 'n2p_tests', 'run_result', 'test_patch_result', 'fix_patch_result' ] ``` ## sample ```python 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}, } ```