README.md

---
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}, 
}
```