Datasets:

Modalities:
Text
Formats:
parquet
ArXiv:
Libraries:
Datasets
Dask
License:
Dataset Viewer
Auto-converted to Parquet Duplicate
title
stringclasses
1 value
text
stringlengths
30
1.11M
id
stringlengths
27
31
include/nlohmann/detail/json_pointer.hpp/contains bool contains(const BasicJsonType* ptr) const { using size_type = typename BasicJsonType::size_type; for (const auto& reference_token : reference_tokens) { switch (ptr->type()) { case detail::value_...
apositive_train_query0_00000
single_include/nlohmann/json.hpp/contains bool contains(const json_pointer& ptr) const { return ptr.contains(this); }
apositive_train_query0_00001
include/nlohmann/adl_serializer.hpp/adl_serializer/from_json class adl_serializer: static auto from_json(BasicJsonType&& j, ValueType& val) noexcept( noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val))) -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void()) {...
negative_train_query0_00000
include/nlohmann/adl_serializer.hpp/adl_serializer/to_json class adl_serializer: static auto to_json(BasicJsonType& j, ValueType&& val) noexcept( noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val)))) -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void()) { ::nlohm...
negative_train_query0_00001
include/nlohmann/json.hpp/is_number_float constexpr bool is_number_float() const noexcept { return m_type == value_t::number_float; }
negative_train_query0_00002
include/nlohmann/json.hpp/swap void swap(string_t& other) { // swap only works for strings if (JSON_HEDLEY_LIKELY(is_string())) { std::swap(*(m_value.string), other); } else { JSON_THROW(type_error::create(310, "cannot use swap() with " + s...
negative_train_query0_00003
include/nlohmann/json.hpp/is_number_unsigned constexpr bool is_number_unsigned() const noexcept { return m_type == value_t::number_unsigned; }
negative_train_query0_00004
include/nlohmann/json.hpp/back reference back() { auto tmp = end(); --tmp; return *tmp; }
negative_train_query0_00005
include/nlohmann/json.hpp/begin iterator begin() noexcept { iterator result(this); result.set_begin(); return result; }
negative_train_query0_00006
include/nlohmann/json.hpp/to_msgpack static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o) { binary_writer<uint8_t>(o).write_msgpack(j); }
negative_train_query0_00007
include/nlohmann/json.hpp/to_ubjson static std::vector<uint8_t> to_ubjson(const basic_json& j, const bool use_size = false, const bool use_type = false) { std::vector<uint8_t> result; to_ubjson(j, result, use_siz...
negative_train_query0_00008
include/nlohmann/json.hpp/from_cbor JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json from_cbor(detail::input_adapter&& i, const bool strict = true, const bool allow_exceptions = true) { basic_json result; detail::json_sax_dom_pa...
negative_train_query0_00009
include/nlohmann/json.hpp/from_ubjson JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json from_ubjson(A1 && a1, A2 && a2, const bool strict = true, const bool allow_exceptions = true) { basic_json result; detail::json_sax_dom_p...
negative_train_query0_00010
include/nlohmann/json.hpp/basic_json basic_json(std::nullptr_t = nullptr) noexcept : basic_json(value_t::null) { assert_invariant(); }
negative_train_query0_00011
include/nlohmann/json.hpp/push_back void push_back(const basic_json& val) { // push_back only works for null objects or arrays if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array()))) { JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()...
negative_train_query0_00012
include/nlohmann/json.hpp/value string_t value(const typename object_t::key_type& key, const char* default_value) const { return value(key, string_t(default_value)); }
negative_train_query0_00013
include/nlohmann/json.hpp/cend const_iterator cend() const noexcept { const_iterator result(this); result.set_end(); return result; }
negative_train_query0_00014
include/nlohmann/json.hpp/crend const_reverse_iterator crend() const noexcept { return const_reverse_iterator(cbegin()); }
negative_train_query0_00015
include/nlohmann/json.hpp/from_bson JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json from_bson(A1 && a1, A2 && a2, const bool strict = true, const bool allow_exceptions = true) { basic_json result; detail::json_sax_dom_parser<ba...
negative_train_query0_00016
include/nlohmann/json.hpp/unflatten basic_json unflatten() const { return json_pointer::unflatten(*this); }
negative_train_query0_00017
include/nlohmann/json.hpp/end iterator end() noexcept { iterator result(this); result.set_end(); return result; }
negative_train_query0_00018
include/nlohmann/json.hpp/crbegin const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(cend()); }
negative_train_query0_00019
include/nlohmann/json.hpp/merge_patch void merge_patch(const basic_json& apply_patch) { if (apply_patch.is_object()) { if (not is_object()) { *this = object(); } for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it) ...
negative_train_query0_00020
include/nlohmann/json.hpp/front const_reference front() const { return *cbegin(); }
negative_train_query0_00021
include/nlohmann/json.hpp/from_msgpack JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json from_msgpack(A1 && a1, A2 && a2, const bool strict = true, const bool allow_exceptions = true) { basic_json result; detail::json_sax_d...
negative_train_query0_00022
include/nlohmann/json.hpp/get_allocator static allocator_type get_allocator() { return allocator_type(); }
negative_train_query0_00023
include/nlohmann/json.hpp/is_boolean constexpr bool is_boolean() const noexcept { return m_type == value_t::boolean; }
negative_train_query0_00024
include/nlohmann/json.hpp/cbegin const_iterator cbegin() const noexcept { const_iterator result(this); result.set_begin(); return result; }
negative_train_query0_00025
include/nlohmann/json.hpp/insert iterator insert(const_iterator pos, basic_json&& val) { return insert(pos, val); }
negative_train_query0_00026
include/nlohmann/json.hpp/patch basic_json patch(const basic_json& json_patch) const { // make a working copy to apply the patch to basic_json result = *this; // the valid JSON Patch operations enum class patch_operations {add, remove, replace, move, copy, test, invalid}; ...
negative_train_query0_00027
include/nlohmann/json.hpp/array JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json array(initializer_list_t init = {}) { return basic_json(init, false, value_t::array); }
negative_train_query0_00028
include/nlohmann/json.hpp/is_null constexpr bool is_null() const noexcept { return m_type == value_t::null; }
negative_train_query0_00029
include/nlohmann/json.hpp/JSON_INTERNAL_CATCH ValueType value(const json_pointer& ptr, const ValueType& default_value) const { // at only works for objects if (JSON_HEDLEY_LIKELY(is_object())) { // if pointer resolves a value, return it or use default value JSON_T...
negative_train_query0_00030
include/nlohmann/json.hpp/is_number_integer constexpr bool is_number_integer() const noexcept { return m_type == value_t::number_integer or m_type == value_t::number_unsigned; }
negative_train_query0_00031
include/nlohmann/json.hpp/rbegin reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
negative_train_query0_00032
include/nlohmann/json.hpp/accept static bool accept(IteratorType first, IteratorType last) { return parser(detail::input_adapter(first, last)).accept(true); }
negative_train_query0_00033
include/nlohmann/json.hpp/is_number constexpr bool is_number() const noexcept { return is_number_integer() or is_number_float(); }
negative_train_query0_00034
include/nlohmann/json.hpp/to_bson static std::vector<uint8_t> to_bson(const basic_json& j) { std::vector<uint8_t> result; to_bson(j, result); return result; }
negative_train_query0_00035
include/nlohmann/json.hpp/erase IteratorType erase(IteratorType first, IteratorType last) { // make sure iterator fits the current value if (JSON_HEDLEY_UNLIKELY(this != first.m_object or this != last.m_object)) { JSON_THROW(invalid_iterator::create(203, "iterators do not fit...
negative_train_query0_00036
include/nlohmann/json.hpp/sax_parse static bool sax_parse(IteratorType first, IteratorType last, SAX* sax) { return parser(detail::input_adapter(first, last)).sax_parse(sax); }
negative_train_query0_00037
include/nlohmann/json.hpp/object JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json object(initializer_list_t init = {}) { return basic_json(init, false, value_t::object); }
negative_train_query0_00038
include/nlohmann/json.hpp/is_string constexpr bool is_string() const noexcept { return m_type == value_t::string; }
negative_train_query0_00039
include/nlohmann/json.hpp/rend reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
negative_train_query0_00040
include/nlohmann/json.hpp/JSON_CATCH JSON_CATCH (std::out_of_range&) { // create better exception explanation JSON_THROW(out_of_range::create(403, "key '" + key + "' not found")); }
negative_train_query0_00041
include/nlohmann/json.hpp/to_cbor static void to_cbor(const basic_json& j, detail::output_adapter<char> o) { binary_writer<char>(o).write_cbor(j); }
negative_train_query0_00042
include/nlohmann/json.hpp/is_discarded constexpr bool is_discarded() const noexcept { return m_type == value_t::discarded; }
negative_train_query0_00043
include/nlohmann/json.hpp/count size_type count(KeyT&& key) const { // return 0 for all nonobject types return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0; }
negative_train_query0_00044
include/nlohmann/json.hpp/type constexpr value_t type() const noexcept { return m_type; }
negative_train_query0_00045
include/nlohmann/json.hpp/is_array constexpr bool is_array() const noexcept { return m_type == value_t::array; }
negative_train_query0_00046
include/nlohmann/json.hpp/diff JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json diff(const basic_json& source, const basic_json& target, const std::string& path = "") { // the patch basic_json result(value_t::array); // if the values are the same, return e...
negative_train_query0_00047
include/nlohmann/json.hpp/is_object constexpr bool is_object() const noexcept { return m_type == value_t::object; }
negative_train_query0_00048
include/nlohmann/json.hpp/clear void clear() noexcept { switch (m_type) { case value_t::number_integer: { m_value.number_integer = 0; break; } case value_t::number_unsigned: { m_value.num...
negative_train_query0_00049
include/nlohmann/json.hpp/is_structured constexpr bool is_structured() const noexcept { return is_array() or is_object(); }
negative_train_query0_00050
include/nlohmann/json.hpp/at const_reference at(const json_pointer& ptr) const { return ptr.get_checked(this); }
negative_train_query0_00051
include/nlohmann/json.hpp/is_primitive constexpr bool is_primitive() const noexcept { return is_null() or is_string() or is_boolean() or is_number(); }
negative_train_query0_00052
include/nlohmann/json.hpp/contains bool contains(KeyT && key) const { return is_object() and m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end(); }
negative_train_query0_00053
include/nlohmann/json.hpp/emplace std::pair<iterator, bool> emplace(Args&& ... args) { // emplace only works for null objects or arrays if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object()))) { JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(typ...
negative_train_query0_00054
include/nlohmann/json.hpp/parse static basic_json parse(IteratorType first, IteratorType last, const parser_callback_t cb = nullptr, const bool allow_exceptions = true) { basic_json result; parser(detail::input_adapter(first, last), cb, all...
negative_train_query0_00055
include/nlohmann/json.hpp/find const_iterator find(KeyT&& key) const { auto result = cend(); if (is_object()) { result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key)); } return result; }
negative_train_query0_00056
include/nlohmann/json.hpp/emplace_back reference emplace_back(Args&& ... args) { // emplace_back only works for null objects or arrays if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array()))) { JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(...
negative_train_query0_00057
include/nlohmann/json.hpp/flatten basic_json flatten() const { basic_json result(value_t::object); json_pointer::flatten("", *this, result); return result; }
negative_train_query0_00058
include/nlohmann/json.hpp/meta JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json meta() { basic_json result; result["copyright"] = "(C) 2013-2017 Niels Lohmann"; result["name"] = "JSON for Modern C++"; result["url"] = "https://github.com/nlohmann/json"; result["versio...
negative_train_query0_00059
include/nlohmann/json.hpp/update void update(const_reference j) { // implicitly convert null value to an empty object if (is_null()) { m_type = value_t::object; m_value.object = create<object_t>(); assert_invariant(); } if (JSON_HEDLEY...
negative_train_query0_00060
include/nlohmann/json.hpp/insert_iterator iterator insert_iterator(const_iterator pos, Args&& ... args) { iterator result(this); assert(m_value.array != nullptr); auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator); m_value.array->insert(pos.m_it.arr...
negative_train_query0_00061
include/nlohmann/json.hpp/assert_invariant void assert_invariant() const noexcept { assert(m_type != value_t::object or m_value.object != nullptr); assert(m_type != value_t::array or m_value.array != nullptr); assert(m_type != value_t::string or m_value.string != nullptr); }
negative_train_query0_00062
include/nlohmann/json.hpp/json_value/json_value class json_value: json_value(array_t&& value) { array = create<array_t>(std::move(value)); }
negative_train_query0_00063
include/nlohmann/detail/json_ref.hpp/json_ref/json_ref class json_ref: json_ref(Args && ... args) : owned_value(std::forward<Args>(args)...), value_ref(&owned_value), is_rvalue(true) {}
negative_train_query0_00064
include/nlohmann/detail/exceptions.hpp/parse_error/parse_error class parse_error: parse_error(int id_, std::size_t byte_, const char* what_arg) : exception(id_, what_arg), byte(byte_) {}
negative_train_query0_00065
include/nlohmann/detail/json_pointer.hpp/split static std::vector<std::string> split(const std::string& reference_string) { std::vector<std::string> result; // special case: empty reference string -> no reference tokens if (reference_string.empty()) { return result; ...
negative_train_query0_00066
include/nlohmann/detail/json_pointer.hpp/escape static std::string escape(std::string s) { replace_substring(s, "~", "~0"); replace_substring(s, "/", "~1"); return s; }
negative_train_query0_00067
include/nlohmann/detail/json_pointer.hpp/unflatten static BasicJsonType unflatten(const BasicJsonType& value) { if (JSON_HEDLEY_UNLIKELY(not value.is_object())) { JSON_THROW(detail::type_error::create(314, "only objects can be unflattened")); } BasicJsonType resu...
negative_train_query0_00068
include/nlohmann/detail/json_pointer.hpp/replace_substring static void replace_substring(std::string& s, const std::string& f, const std::string& t) { assert(not f.empty()); for (auto pos = s.find(f); // find first occurrence of f ...
negative_train_query0_00069
include/nlohmann/detail/json_pointer.hpp/unescape static void unescape(std::string& s) { replace_substring(s, "~1", "/"); replace_substring(s, "~0", "~"); }
negative_train_query0_00070
include/nlohmann/detail/json_pointer.hpp/flatten static void flatten(const std::string& reference_string, const BasicJsonType& value, BasicJsonType& result) { switch (value.type()) { case detail::value_t::array: { ...
negative_train_query0_00071
include/nlohmann/detail/json_pointer.hpp/json_pointer/json_pointer class json_pointer: explicit json_pointer(const std::string& s = "") : reference_tokens(split(s)) {}
negative_train_query0_00072
include/nlohmann/detail/json_pointer.hpp/json_pointer/JSON_CATCH class json_pointer: JSON_CATCH(std::out_of_range&) { JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'")); }
negative_train_query0_00073
include/nlohmann/detail/input/input_adapters.hpp/input_stream_adapter/input_stream_adapter class input_stream_adapter: input_stream_adapter(const input_stream_adapter&) = delete;
negative_train_query0_00074
include/nlohmann/detail/input/input_adapters.hpp/input_buffer_adapter/input_buffer_adapter class input_buffer_adapter: input_buffer_adapter(input_buffer_adapter&&) = delete;
negative_train_query0_00075
include/nlohmann/detail/input/input_adapters.hpp/file_input_adapter/file_input_adapter class file_input_adapter: file_input_adapter(file_input_adapter&&) = default;
negative_train_query0_00076
include/nlohmann/detail/input/input_adapters.hpp/wide_string_input_adapter/wide_string_input_adapter class wide_string_input_adapter: explicit wide_string_input_adapter(const WideStringType& w) noexcept : str(w) {}
negative_train_query0_00077
include/nlohmann/detail/input/input_adapters.hpp/wide_string_input_adapter/fill_buffer class wide_string_input_adapter: void fill_buffer() { wide_string_input_helper<WideStringType, T>::fill_buffer(str, current_wchar, utf8_bytes, utf8_bytes_index, utf8_bytes_filled); }
negative_train_query0_00078
include/nlohmann/detail/input/input_adapters.hpp/input_adapter/input_adapter class input_adapter: input_adapter(const ContiguousContainer& c) : input_adapter(std::begin(c), std::end(c)) {}
negative_train_query0_00079
include/nlohmann/detail/input/lexer.hpp/lexer/lexer class lexer: lexer(lexer&&) = delete;
negative_train_query0_00080
include/nlohmann/detail/input/binary_reader.hpp/binary_reader/binary_reader class binary_reader: binary_reader(const binary_reader&) = delete;
negative_train_query0_00081
include/nlohmann/detail/input/binary_reader.hpp/binary_reader/get_string class binary_reader: bool get_string(const input_format_t format, const NumberType len, string_t& result) { bool success = true; std::generate_n(std::back_inserter(result), len, [this,...
negative_train_query0_00082
include/nlohmann/detail/input/binary_reader.hpp/binary_reader/get_number class binary_reader: bool get_number(const input_format_t format, NumberType& result) { // step 1: read input into array with system's byte order std::array<std::uint8_t, sizeof(NumberType)> vec; for (std::size_t i =...
negative_train_query0_00083
include/nlohmann/detail/input/binary_reader.hpp/binary_reader/get_bson_string class binary_reader: bool get_bson_string(const NumberType len, string_t& result) { if (JSON_HEDLEY_UNLIKELY(len < 1)) { auto last_token = get_token_string(); return sax->parse_error(chars_read, ...
negative_train_query0_00084
include/nlohmann/detail/input/parser.hpp/parser/parser class parser: explicit parser(detail::input_adapter_t&& adapter, const parser_callback_t cb = nullptr, const bool allow_exceptions_ = true) : callback(cb), m_lexer(std::move(adapter)), allow_exceptions(allow_except...
negative_train_query0_00085
include/nlohmann/detail/input/parser.hpp/parser/sax_parse_internal class parser: bool sax_parse_internal(SAX* sax) { // stack to remember the hierarchy of structured values we are parsing // true = array; false = object std::vector<bool> states; // value to avoid a goto (see comme...
negative_train_query0_00086
include/nlohmann/detail/input/parser.hpp/parser/sax_parse class parser: bool sax_parse(SAX* sax, const bool strict = true) { (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {}; const bool result = sax_parse_internal(sax); // strict mode: next byte must be EOF if (result a...
negative_train_query0_00087
include/nlohmann/detail/input/json_sax.hpp/json_sax_dom_parser/json_sax_dom_parser class json_sax_dom_parser: json_sax_dom_parser(json_sax_dom_parser&&) = default;
negative_train_query0_00088
include/nlohmann/detail/input/json_sax.hpp/json_sax_dom_callback_parser/json_sax_dom_callback_parser class json_sax_dom_callback_parser: json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default;
negative_train_query0_00089
include/nlohmann/detail/input/json_sax.hpp/json_sax_dom_callback_parser/handle_value class json_sax_dom_callback_parser: std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false) { assert(not keep_stack.empty()); // do not handle this value if we know it would be ...
negative_train_query0_00090
include/nlohmann/detail/output/binary_writer.hpp/binary_writer/binary_writer class binary_writer: explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter) { assert(oa); }
negative_train_query0_00091
include/nlohmann/detail/output/binary_writer.hpp/binary_writer/write_number_with_ubjson_prefix class binary_writer: void write_number_with_ubjson_prefix(const NumberType n, const bool add_prefix) { if (add_prefix) { oa->write_character(get_ubjs...
negative_train_query0_00092
include/nlohmann/detail/output/binary_writer.hpp/binary_writer/write_number class binary_writer: void write_number(const NumberType n) { // step 1: write number to array of length NumberType std::array<CharType, sizeof(NumberType)> vec; std::memcpy(vec.data(), &n, sizeof(NumberType)); ...
negative_train_query0_00093
include/nlohmann/detail/output/binary_writer.hpp/binary_writer/to_char_type class binary_writer: static constexpr CharType to_char_type(InputCharType x) noexcept { return x; }
negative_train_query0_00094
include/nlohmann/detail/output/serializer.hpp/serializer/serializer class serializer: serializer(serializer&&) = delete;
negative_train_query0_00095
include/nlohmann/detail/output/serializer.hpp/serializer/dump_integer class serializer: void dump_integer(NumberType x) { static constexpr std::array<std::array<char, 2>, 100> digits_to_99 { { {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0',...
negative_train_query0_00096
include/nlohmann/detail/output/output_adapters.hpp/output_vector_adapter/output_vector_adapter class output_vector_adapter: explicit output_vector_adapter(std::vector<CharType>& vec) noexcept : v(vec) {}
negative_train_query0_00097
End of preview. Expand in Data Studio

MultiSWEbenchRR

An MTEB dataset
Massive Text Embedding Benchmark

Multilingual Software Issue Localization.

Task category t2t
Domains Programming, Written
Reference https://multi-swe-bench.github.io/#/

Source datasets:

How to evaluate on this task

You can evaluate an embedding model on this dataset using the following code:

import mteb

task = mteb.get_task("MultiSWEbenchRR")
evaluator = mteb.MTEB([task])

model = mteb.get_model(YOUR_MODEL)
evaluator.run(model)

To learn more about how to run models on mteb task check out the GitHub repository.

Citation

If you use this dataset, please cite the dataset as well as mteb, as this dataset likely includes additional processing as a part of the MMTEB Contribution.


@misc{zan2025multiswebench,
  archiveprefix = {arXiv},
  author = {Daoguang Zan and Zhirong Huang and Wei Liu and Hanwu Chen and Linhao Zhang and Shulin Xin and Lu Chen and Qi Liu and Xiaojian Zhong and Aoyan Li and Siyao Liu and Yongsheng Xiao and Liangqiang Chen and Yuyu Zhang and Jing Su and Tianyu Liu and Rui Long and Kai Shen and Liang Xiang},
  eprint = {2504.02605},
  primaryclass = {cs.SE},
  title = {Multi-SWE-bench: A Multilingual Benchmark for Issue Resolving},
  url = {https://arxiv.org/abs/2504.02605},
  year = {2025},
}


@article{enevoldsen2025mmtebmassivemultilingualtext,
  title={MMTEB: Massive Multilingual Text Embedding Benchmark},
  author={Kenneth Enevoldsen and Isaac Chung and Imene Kerboua and Márton Kardos and Ashwin Mathur and David Stap and Jay Gala and Wissam Siblini and Dominik Krzemiński and Genta Indra Winata and Saba Sturua and Saiteja Utpala and Mathieu Ciancone and Marion Schaeffer and Gabriel Sequeira and Diganta Misra and Shreeya Dhakal and Jonathan Rystrøm and Roman Solomatin and Ömer Çağatan and Akash Kundu and Martin Bernstorff and Shitao Xiao and Akshita Sukhlecha and Bhavish Pahwa and Rafał Poświata and Kranthi Kiran GV and Shawon Ashraf and Daniel Auras and Björn Plüster and Jan Philipp Harries and Loïc Magne and Isabelle Mohr and Mariya Hendriksen and Dawei Zhu and Hippolyte Gisserot-Boukhlef and Tom Aarsen and Jan Kostkan and Konrad Wojtasik and Taemin Lee and Marek Šuppa and Crystina Zhang and Roberta Rocca and Mohammed Hamdy and Andrianos Michail and John Yang and Manuel Faysse and Aleksei Vatolin and Nandan Thakur and Manan Dey and Dipam Vasani and Pranjal Chitale and Simone Tedeschi and Nguyen Tai and Artem Snegirev and Michael Günther and Mengzhou Xia and Weijia Shi and Xing Han Lù and Jordan Clive and Gayatri Krishnakumar and Anna Maksimova and Silvan Wehrli and Maria Tikhonova and Henil Panchal and Aleksandr Abramov and Malte Ostendorff and Zheng Liu and Simon Clematide and Lester James Miranda and Alena Fenogenova and Guangyu Song and Ruqiya Bin Safi and Wen-Ding Li and Alessia Borghini and Federico Cassano and Hongjin Su and Jimmy Lin and Howard Yen and Lasse Hansen and Sara Hooker and Chenghao Xiao and Vaibhav Adlakha and Orion Weller and Siva Reddy and Niklas Muennighoff},
  publisher = {arXiv},
  journal={arXiv preprint arXiv:2502.13595},
  year={2025},
  url={https://arxiv.org/abs/2502.13595},
  doi = {10.48550/arXiv.2502.13595},
}

@article{muennighoff2022mteb,
  author = {Muennighoff, Niklas and Tazi, Nouamane and Magne, Loïc and Reimers, Nils},
  title = {MTEB: Massive Text Embedding Benchmark},
  publisher = {arXiv},
  journal={arXiv preprint arXiv:2210.07316},
  year = {2022}
  url = {https://arxiv.org/abs/2210.07316},
  doi = {10.48550/ARXIV.2210.07316},
}

Dataset Statistics

Dataset Statistics

The following code contains the descriptive statistics from the task. These can also be obtained using:

import mteb

task = mteb.get_task("MultiSWEbenchRR")

desc_stats = task.metadata.descriptive_stats
{}

This dataset card was automatically generated using MTEB

Downloads last month
155

Papers for mteb/MultiSWEbenchRR