Datasets:

Modalities:
Text
Formats:
parquet
Languages:
code
License:
Dataset Viewer
Auto-converted to Parquet Duplicate
content
large_stringlengths
48
7.98M
membership
large_stringclasses
2 values
package crypto import ( "encoding/hex" "testing" "github.com/XunleiBlockchain/tc-libs/common" "github.com/stretchr/testify/assert" ) func TestGeneratePrivKey(t *testing.T) { testPriv, err := GenPrivKeyEd25519() if err != nil { t.Fatalf("GenPrivKeyEd25519 fail: %s", err) } testGenerate := testPriv.Generate(...
non-member
package aws import ( "github.com/aws/aws-sdk-go/aws" elasticsearch "github.com/aws/aws-sdk-go/service/elasticsearchservice" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" ) func expandAdvancedSecurityOptions(m []interface{}) *elasticsearch.AdvancedSecurityOptionsInput { config := elasticsearch.Advan...
non-member
package otto import ( "bytes" "encoding/json" "fmt" "strings" ) type _builtinJSON_parseContext struct { call FunctionCall reviver Value } func builtinJSON_parse(call FunctionCall) Value { ctx := _builtinJSON_parseContext{ call: call, } revive := false if reviver := call.Argument(1); reviver.isCallable...
member
package comparel import ( "reflect" "strconv" "strings" ) // DeepGreater 深度比较a的field字段的值是否大于b的field字段的值 func DeepGreater(a, b interface{}, field string) bool { return deep(a, b, field, deepValueGreater) } // DeepLesser 深度比较a的field字段的值是否小于b的field字段的值 func DeepLesser(a, b interface{}, field string) bool { return ...
non-member
// Copyright 2016 The go-ethereum Authors // This file is part of the go-ethereum library. // // The go-ethereum library is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License...
member
package dialer import ( "context" "net" "github.com/Dreamacro/clash/common/atomic" "github.com/Dreamacro/clash/component/resolver" ) var ( DefaultOptions []Option DefaultInterface = atomic.NewTypedValue[string]("") DefaultRoutingMark = atomic.NewInt32(0) ) type NetDialer interface { DialContext(ctx co...
non-member
package pehape import "testing" func TestFunction(t *testing.T) { tests := []struct { name string expected string err error num float64 opts []string }{ {"1000", "1000", nil, 1000.12, nil}, {"error param > 4", "", errMust4Params, 1000.12, []string{"3", "4", "5", "5"}}, {"param 2 no...
non-member
// Copyright 2023 <chaishushan{AT}gmail.com>. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package render import ( "bytes" "fmt" "io" "strings" ) type SidebarTree []*SidebarItem func (p SidebarTree) GenHTML(pageRoot string, pageInde...
non-member
package units_test import ( "encoding/json" "time" . "github.com/onsi/ginkgo" . "github.com/onsi/ginkgo/extensions/table" . "github.com/onsi/gomega" "github.com/alext/heating-controller/units" ) var _ = Describe("TimeOfDay", func() { DescribeTable("constructing and forammting", func(t units.TimeOfDay, exp...
non-member
package client import ( "bytes" "github.com/hoffie/larasync/repository" "github.com/hoffie/larasync/repository/nib" ) // Downloader returns the downloader configured for the client // and the passed ClientRepository. func (c *Client) Downloader(r *repository.ClientRepository) *Downloader { return &Downloader{ ...
non-member
package sqlite import "database/sql" // statementCreator allows to pass transaction or database to use in consumer. type StatementCreator interface { Prepare(query string) (*sql.Stmt, error) }
non-member
// Copyright 2014 The Go Authors. // See https://code.google.com/p/go/source/browse/CONTRIBUTORS // Licensed under the same terms as Go itself: // https://code.google.com/p/go/source/browse/LICENSE // +build h2demo package main import ( "bytes" "crypto/tls" "flag" "fmt" "hash/crc32" "image" "image/jpeg" "io"...
member
// Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package webdav import ( "fmt" "net/http" "os" "reflect" "sort" "testing" "golang.org/x/net/webdav/internal/xml" ) func TestMemPS(t *testing.T) { // c...
member
package emails import ( "os" "os/signal" "syscall" "oott/helper" ) type EmailScanner interface { ScanEmails(domain string) ([]EmailDetails, error) } type EmailDetails struct { Email string Source string } // Cancel Sign handling var cancel = make(chan struct{}) func InterruptHandler() { // Create a chann...
non-member
// Copyright 2014 The go-ethereum Authors // This file is part of Webchain. // // Webchain is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any l...
non-member
package minigo const CacheSize = 16 type Cache struct { curId int maxId int container [][]byte } func NewCache() *Cache { return &Cache{ curId: 0, container: make([][]byte, CacheSize), } } func (c *Cache) Reset() { c.curId = 0 c.maxId = -1 } func (c *Cache) Add(msg []byte) { if c.curId > c....
non-member
package cpu import ( "fmt" "os" "runtime" "testing" "time" ) func TestCpu_times(t *testing.T) { v, err := Times(false) if err != nil { t.Errorf("error %v", err) } if len(v) == 0 { t.Error("could not get CPUs ", err) } empty := TimesStat{} for _, vv := range v { if vv == empty { t.Errorf("could no...
member
// +build windows package remote import ( "errors" "os" ) func NewOutputInterceptor() OutputInterceptor { return &outputInterceptor{} } type outputInterceptor struct { intercepting bool } func (interceptor *outputInterceptor) StartInterceptingOutput() error { if interceptor.intercepting { return errors.New(...
member
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved. // Use of this source code is governed by a MIT license that can // be found in the LICENSE file. package termui import ( "image" "os" "sync" tb "github.com/hawklithm/termbox-go" ) type Drawable interface { GetRect() image.Rectangle SetRe...
member
package database import ( "bytes" "context" "strings" "testing" "go.mongodb.org/mongo-driver/bson" ) func TestConnect(t *testing.T) { db := Connect() db.Faculty.Drop(context.TODO()) var documents []bson.D db.Faculty.Decode(&documents) assert(t, len(documents) == 0, "Expected collection to be empty after...
non-member
// This file is part of Gate. // Copyright (C) 2012-2015 Cyril Adrian <cyril.adrian@gmail.com> // // Gate is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // Gate is distributed i...
non-member
package storage import ( "encoding/json" "os" "path/filepath" "strings" "syscall" ) // Storage is an interface to interact with the storage type Storage struct { // Opts are the options for the storage Opts StorageOptions } // StorageOptions are the options for the storage type StorageOptions struct { // Roo...
non-member
package mongo import ( "encoding/json" "io" "os" "strings" "time" "github.com/johnwilson/bytengine" "github.com/johnwilson/bytengine/bytestore" "github.com/nu7hatch/gouuid" "gopkg.in/mgo.v2" ) type Config struct { Addresses []string `json:"addresses"` Timeout time.Duration `json:"timeout"` ...
member
End of preview. Expand in Data Studio

ICSE 2027 Heap Membership-Inference Dataset — Public Competition Release

This is the public competition release of the ICSE 2027 membership-inference benchmark for Go, Java, Python, Ruby, and Rust. It contains train and validation only.

The release contains 54,040 source-code files.

Loading the dataset

pip install datasets

Each programming language is a separate, case-sensitive configuration:

from datasets import load_dataset

python_data = load_dataset(
    "Poisoned-Chalice/ICSE-2027-public",
    "Python",
)

print(python_data)
# DatasetDict with train and validation only; no test split is published.

Load one public split:

python_validation = load_dataset(
    "Poisoned-Chalice/ICSE-2027-public",
    "Python",
    split="validation",
)

Dataset structure

Configuration Train Validation Public total
Go 10,000 1,000 11,000
Java 10,000 1,000 11,000
Python 10,000 1,000 11,000
Ruby 10,000 1,000 11,000
Rust 9,040 1,000 10,040

Every public split is exactly balanced between member and non-member. The 10,000-row training splits contain 5,000 files per label; Rust training contains 4,520 files per label. Every validation split contains 500 files per label.

Each row has two columns:

Column Type Description
content large_string Complete source-code file contents
membership large_string The string member or non-member

The language is represented by the configuration name. Repository paths, filenames, original repository identifiers, per-file license metadata, source duplicate annotations, and classifier predictions are not published.

Provenance and labels

The benchmark is derived from The Heap. A file is a member when it is marked as an exact duplicate in both Stack v1 and Stack v2. A file is a non-member when its exact- and near-duplicate flags are false in both versions. Null, ambiguous, and mixed cases are excluded.

The benchmark applies classifier-based hard-example selection and near-duplicate filtering before constructing balanced, content-disjoint splits. Exact private split parameters, the source revision, generation manifest, and hidden-test artifacts are deliberately excluded from this public repository to protect the competition.

These labels describe overlap with the Stack corpora; they do not prove that an arbitrary model was trained on a particular file.

Limitations and responsible use

  • This is an intentionally difficult subset and is not an IID sample of The Heap, so results should not be interpreted as population-wide attack performance.
  • Membership is a Stack-overlap proxy, not verified training membership for a particular model.
  • The labels inherit the accuracy and limitations of the source duplicate annotations.
  • Row-level repository provenance and license metadata are absent from the published schema.

The upstream The Heap dataset card declares GPL-3.0. Individual source files may remain subject to the copyright and license terms of their originating repositories. Treat all source code as untrusted text: do not execute samples without appropriate isolation and review.

This benchmark is intended for privacy, memorization, and membership-inference research. It should not be used to make claims about individual authors, establish code ownership, or infer that a deployed model used a specific file without additional evidence.

Removal requests concerning source material can be directed through The Heap opt-out process.

Citation

Please cite the source dataset:

@inproceedings{katzy2025heap,
  author    = {Jonathan Katzy and Razvan Mihai Popescu and
               Arie van Deursen and Maliheh Izadi},
  title     = {The Heap: A Contamination-Free Multilingual Code Dataset
               for Evaluating Large Language Models},
  booktitle = {2025 IEEE/ACM Second International Conference on
               AI Foundation Models and Software Engineering (Forge)},
  year      = {2025},
  pages     = {151--155},
  doi       = {10.1109/Forge66646.2025.00025}
}
Downloads last month
-