drcoolio/github-clean

Dataset Summary

This dataset was created for my GitHub issues collection project for Assessment 1 at North Metropolitan TAFE. It contains 5,000 records of software issues and pull requests gathered directly from the official Hugging Face datasets repository on GitHub. The dataset is stored in Parquet format on the Hugging Face Hub under my account drcoolio/github-clean with a total file size of 4.67 MB. I collected this dataset on 20 October 2026 to capture repository activity up to issue number 8858 and to support natural language processing tasks including text classification, sentiment analysis behind the pipeline, and semantic search using FAISS vector indexes. All records are in English and focus on technical discussions, bug reports, and code changes in data engineering and machine learning.

Metadata Tags • Modalities: Tabular, Text • Formats: Parquet, JSON Lines • Size Category: 1K to 10K (5,000 rows, 4.67 MB) • Language: English • Libraries: Datasets, Pandas, Polars, PyTorch • Task Categories: Text Classification, Text Retrieval, Document Retrieval, Sentiment Analysis

How to use

The dataset has one split, called train. Load it with the Datasets library:

from datasets import load_dataset

ds = load_dataset("drcoolio/github-clean")

To work with it in pandas:

df = ds["train"].to_pandas()

The first 100 rows appear twice, the same problem as version 1, see Reliability checks. This keeps one row for each issue or pull request number:

df = df.drop_duplicates(subset="number")

Dataset details

Each row in the dataset represents one GitHub issue or pull request record returned by the GitHub REST API from the huggingface/datasets repository, along with one derived boolean column that I created during data augmentation. Of the 5,000 rows, 2,878 are pull requests and 2,122 are issues, while 1,409 are open and 3,591 are closed. The items were created between 25 February 2022 and 20 October 2026, and their numbers run from 3,790 to 8,858. For example, record index 0 corresponds to issue number 8858, record index 1 corresponds to pull request number 8857, and the final row in the raw file corresponds to pull request number 3790.

Data fields

The dataset contains 37 columns in total (36 raw fields from the GitHub REST API response in October 2026 plus 1 derived feature): • url (string): The API URL for the specific issue record. • repository_url (string): The API URL for the parent huggingface/datasets repository. • labels_url (string): The API template URL for issue labels. • comments_url (string): The API URL used to fetch discussion comments for the issue. • events_url (string): The API URL for issue lifecycle events. • html_url (string): The direct web browser link to the GitHub issue or pull request. • id (int64): The unique database identifier assigned by GitHub. • node_id (string): The global GraphQL node identifier. • number (int64): The sequential issue or pull request number in the repository. • title (string): The summary title written by the person who opened the issue. • user (struct): A nested dictionary containing public profile details of the author (login, id, node_id, avatar_url, html_url, type, user_view_type, site_admin). • labels (list of structs): Tags attached to the issue to classify bug types or features. • state (string): Whether the issue is currently open or closed. • locked (bool): Whether the conversation has been locked by maintainers. • assignees (list of structs): Developers assigned to resolve the issue. • milestone (struct): Project milestone details and timestamps if assigned. • comments (int64): The count of comments posted on the issue thread. • created_at (timestamp[s]): The exact date and time when the issue was opened. • updated_at (timestamp[s]): The date and time of the most recent update. • closed_at (timestamp[s]): The date and time when the issue was closed, or None if still open. • assignee (struct): The primary developer assigned to the issue. • author_association (string): The author role in the repository, such as MEMBER, CONTRIBUTOR, or NONE. • issue_field_values (sequence): Custom repository field values returned by the GitHub API. • type (null or string): The issue type classification field. • active_lock_reason (null or string): The reason given if an issue thread is locked. • draft (bool): Indicates if a pull request is still in draft status. • pull_request (struct): A nested dictionary with url, html_url, diff_url, patch_url, and merged_at timestamps. This field is None when the record is a standard issue rather than a pull request. • body (string): The main text description of the bug report, feature request, or pull request. • closed_by (struct): Nested user profile dictionary showing who closed the issue. • reactions (struct): Counts of community emoji reactions (+1, -1, laugh, hooray, confused, heart, rocket, eyes, and total_count). • timeline_url (string): The API URL for timeline activity. • performed_via_github_app (null or struct): Details if an automated GitHub App created the post. • state_reason (string): Explanation for why an issue state changed, such as completed or not_planned. • sub_issues_summary (struct): Summary counts of linked sub issues (total, completed, percent_completed). • issue_dependencies_summary (struct): Counts of blocking or blocked issues (blocked_by, total_blocked_by, blocking, total_blocking). • pinned_comment (null or struct): Details of any pinned comment on the thread. • is_pull_request (bool): The derived feature I engineered using .map() to flag whether the record is a pull request (True) or a standard issue (False).

Data splits

One split, train, with 5,000 rows. The uncompressed dataset size in memory is 19,653,397 bytes and the auto converted Parquet file is 4,663,700 bytes (4.67 MB). I did not make a validation or test split.

Dataset creation

Curation rationale

I built this dataset for Assessment 1 at North Metropolitan TAFE to gather a real world collection of software issues and pull requests from the huggingface/datasets repository. My goal was to prepare a practical text dataset for downstream natural language processing tasks in Task 2 and Task 3, including sequence classification, sentiment analysis, and semantic search with FAISS vector indexes, while learning how to audit data quality, privacy obligations, and organisational policies.

Data collection process

I collected and published the data using my Kaggle notebook session-9-creating-your-own-dataset.ipynb running on Python 3.11.13, with internet on and no GPU, on 20 October 2026. The step by step process I followed in order is documented below:

1. Initial API test: I sent one test GET request with the Python requests library to https://api.github.com/repos/huggingface/datasets/issues?page=2&per_page=50. I checked response.status_code to confirm a 200 status and verified that len(response.json()) returned 50 records.
2. Sample inspection: I printed the first record of that test response to inspect its JSON shape. I printed only one record rather than all fifty so that fewer contributors' public profile details appeared in the notebook output.
3. Secure authentication: Because unauthenticated GitHub requests have a strict rate limit, I kept the placeholder comment # DON'T PUT YOUR TOKEN DIRECTLY IN HERE in my code and stored my personal GitHub token in Kaggle Secrets under the label "github". I read it in the notebook using UserSecretsClient() and passed it in the request header as headers = {"Authorization": f"token {GITHUB_TOKEN}"}.
4. Automated harvesting (fetch_issues): I wrote and ran the fetch_issues function to download num_issues=5_000 from the huggingface/datasets repository with per_page=100 and state="all", so open and closed items are both included. The function calculated num_pages = 50 using math.ceil() and looped through the pages with tqdm to track progress. Inside the loop, I included a rate limit check (if len(batch) > rate_limit and len(all_issues) < num_issues) that pauses the script for one hour plus one second (time.sleep(60*60 + 1)) so it never crashes from hitting GitHub's 5,000 requests per hour limit.
5. Local serialisation: The function joined the pages into one list, converted the records into a pandas DataFrame using pd.DataFrame.from_records(all_issues), and saved it as a local JSON Lines file called ./datasets-issues.jsonl (orient="records", lines=True).
6. Dataset loading and sample check: I loaded the local JSON Lines file with load_dataset("json", data_files="datasets-issues.jsonl", split="train"), which gave 5,000 rows, and then inspected three random records (issues_dataset.shuffle(seed=666).select(range(3)) and issues_dataset[1]) to see how the pull_request field differs between issues and pull requests.
7. Feature engineering: I added the boolean is_pull_request column, see Augmentation below.
8. Reading Hugging Face credentials: Before logging in, I read two secrets, one named dataset and one named GITHUB, into variables I did not end up using, and then read the dataset secret again into hf_secret, the variable I actually used to log in. That was three secret reads where one would do, left over from my testing in Kaggle.
9. Publishing to Hugging Face Hub: I logged in to Hugging Face using login(token=hf_secret) and ran issues_dataset.push_to_hub("github-clean"). This created the repository and its initial upload commit, 7589747a041bb064d1f5581de2dc6c5984815722, with the commit message "Upload dataset".

Augmentation

The only feature I added is the is_pull_request boolean column, worked out from the pull_request field using .map(lambda x: {"is_pull_request": False if x["pull_request"] is None else True}). Pull requests have a populated dictionary in the pull_request column while standard issues have None. This column is True for 2,878 rows and False for 2,122 rows. I did not fetch or add the text of discussion comments during this step.

Source data producers

The text was written by the software developers and users who opened or managed issues and pull requests in the huggingface/datasets repository. Across the 5,000 rows, 2,104 rows have the author association NONE, 1,434 have MEMBER, 1,235 have CONTRIBUTOR, and 227 have COLLABORATOR. I did not annotate or label any text myself.

Personal and sensitive information

Every record carries the GitHub username, numeric id, avatar link, and profile links of its author, and for some records the assignee, the person who closed the item, and the milestone creator. My test request cell shows one contributor's public profile details, and two of my evidence cells further down show another contributor's profile, so three public profiles appear in the notebook outputs in total. In addition, developers pasting error tracebacks into the body text sometimes leave local file paths, email addresses, or server details. The Risks, corrective actions and future mitigation section below explains how I handle and remove these fields for downstream tasks.

Reliability checks

I checked this dataset myself using the Hugging Face dataset viewer, notebook inspections, and direct row lookups. What matched: the table has 5,000 rows and 37 columns, matching what the notebook requested. Pull requests (2,878) plus issues (2,122) equal 5,000, and open items (1,409) plus closed items (3,591) equal 5,000. The 64 draft and 2,814 not draft pull request flags add up to the 2,878 pull requests. The first row is the most recently created item and the final row is the oldest item in the slice, which matches GitHub's default descending creation order. What did not match: the newest 100 records appear twice. I checked this directly in the table: row 0 and row 100 are both issue number 8858 with the exact same id, and row 99 and row 199 are both number 8759 with the same id, while row 200 moves on to a new record, number 8758. This happened because for page in tqdm(range(num_pages)): starts requesting at page=0, and the GitHub REST API uses 1 based page indexing where page=0 and page=1 return the same first page of 100 records. As a result, the table holds 4,900 unique records rather than 5,000. Also, the issue numbers from 3,790 to 8,858 span 5,069 possible sequential values, meaning 169 numbers in that range do not appear in the API response (for example, deleted or transferred items). Finally, the body field is None in 385 rows (7.7 percent), and non empty bodies vary in length from 1 to 59,917 characters.

Bias and limitations of the data

The data comes from a single repository (huggingface/datasets), so its vocabulary is narrow and specific to Python data loading and machine learning libraries. It is written in English by people who have GitHub accounts and technical backgrounds. Furthermore, it represents the newest slice of 5,000 records at the time of collection rather than a balanced random sample across the whole history of the project, so it reflects what was worked on between February 2022 and October 2026. More than half of the rows (57.6 percent) are pull requests, which mostly describe code changes rather than user questions, and the comments column only stores the integer count of comments rather than the discussion text itself. It is a static snapshot captured on 20 October 2026.

Compliance with legislation and codes

Even though these records come from a public software repository, collecting and republishing them requires careful assessment against Australian and Western Australian privacy laws and open source rules. The records were public and I collected them in a lawful way, though I only partly meet privacy minimisation rules in the raw table because it still includes personal profile fields that I did not need for text analysis. Privacy Act 1988 (Cth) and Australian Privacy Principles (APPs) The Koorliny Kaatijin Privacy Policy states that the organisation follows the Privacy Act 1988 (Cth) and the Australian Privacy Principles, as well as the GDPR where applicable. I am a student working on an educational assessment, so I used the Australian Privacy Principles as my benchmark: Collection (APP 2 and APP 3): Under APP 2 (Anonymity and pseudonymity), contributors interact through GitHub handles. Under APP 3 (Collection of solicited personal information), I used GitHub's documented REST API and my own token to collect data needed for my TAFE assessment, which is a lawful and fair method. However, the raw API response returned nested profile fields (user, assignee, assignees, closed_by) that I did not need for text modelling, and I did not notify individual contributors (APP 5). Partly met. Use and disclosure (APP 6): Contributors opened these issues to discuss software bugs and features on GitHub, not to have their profile dictionaries copied into a separate dataset repository. Republishing the nested person fields is a secondary use that contributors might not expect, even though the records are public. In my downstream Task 2 and Task 3 notebooks, I strip out all user profile columns so only technical fields remain. Cross border disclosure (APP 8): Hugging Face Hub stores dataset files on servers in the United States, and I had not completed a formal overseas transfer check before pushing the raw table. Security of personal information (APP 11): My API tokens were kept in Kaggle Secrets rather than written in the notebook or stored in the dataset, and all API transfers used encrypted HTTPS connections. Openness, access, and correction (APP 1, APP 12, and APP 13): This Dataset Card provides a transparent public record of what I collected, how it is structured, and how any contributor can request access, correction, or removal of their records, see Dataset card authors and contact. Western Australia Privacy and Responsible Information Sharing Act 2024 (PRIS Act 2024) The Privacy and Responsible Information Sharing Act 2024 (WA) and its Information Privacy Principles (IPPs) apply primarily to Western Australian public sector bodies. While a student project on a personal Hugging Face account is not directly bound in the same way as a state agency, I reviewed my workflow against its core principles: IPP 1 (Collection) by using lawful, non intrusive API requests; IPP 2 (Use and Disclosure) by using bug reports for the related educational purpose of building software search tools; IPP 3 (Data Quality) by pulling directly from the official REST API and auditing duplicates; IPP 4 (Data Security) by protecting tokens in Kaggle Secrets and removing unneeded columns before model training; and IPP 5 (Openness) by publishing this Dataset Card. Open source licensing and documentation standards The huggingface/datasets source code repository is licensed under the Apache License 2.0, which covers the codebase published by the maintainers. Because the issue and pull request descriptions were written by hundreds of individual community members and I have not asked each author for permission to relicense their words, I set license: other in the dataset metadata while retaining the html_url column so every record links back to its original author and source page on GitHub. For structure and transparency, this card follows the principles of Datasheets for datasets (Gebru et al., 2021) and the official Hugging Face Dataset Card template and contribution guidelines (CONTRIBUTING.md).

Organisational policy alignment

I checked every stage of this project against the five Koorliny Kaatijin organisational policy documents provided on the LMS (effective 15 October 2025): Koorliny Kaatijin Privacy Policy: This aligns with the Privacy Act 1988 (Cth) assessment above. Keeping the nested contributor profile fields in the published raw table is the main compliance gap, since public availability on GitHub is not the same as explicit consent for republication. Under the policy, any privacy requests or complaints that I cannot resolve directly are escalated to the Koorliny Kaatijin Data Protection Officer and then to the Office of the Australian Information Commissioner (OAIC). Koorliny Kaatijin Data Access and Classification Policy: The policy defines four classification tiers: Public, Internal, Confidential, and Restricted. I labelled this dataset Public because every record originates from a public open source issue tracker on GitHub. However, because the nested user fields can identify individuals, a strict reading places the uncleaned table between Public and Restricted data. To follow data minimisation, I drop 33 metadata and user profile columns during my Task 2 and Task 3 preprocessing before running embeddings. I act as the data owner, and only my authenticated account has write access to the repository. Koorliny Kaatijin Information Security and Acceptable Use Policy: This policy requires individual accounts, bans sharing or hardcoding credentials inside source code, and requires respecting external platform rate limits. In my notebook, I kept the reminder # DON'T PUT YOUR TOKEN DIRECTLY IN HERE and loaded both my GitHub token and my Hugging Face token at runtime via kaggle_secrets.UserSecretsClient(). I also included the time.sleep(60*60 + 1) rate limit check and used HTTPS endpoints. The policy asks for a formal privacy and security check before adopting a third party cloud service, which I had not seen completed for Kaggle or Hugging Face prior to uploading, so that requirement is partly met. Koorliny Kaatijin Data Retention and Disposal Policy: In line with the institutional retention schedule, I keep my final Jupyter Notebooks, reliability checks, and this Dataset Card in my North Metropolitan TAFE OneDrive #Working File directory for five years after the project finishes. The temporary local raw file (./datasets-issues.jsonl) generated inside the Kaggle session is deleted when the container closes, and the public dataset repository will either be replaced with a deidentified copy or deleted once assessment marking is complete. Koorliny Kaatijin Data Breach Response Procedure: A data breach in this project would most likely involve an API token being accidentally exposed in code or a contributor having pasted a private credential, password, or personal email address inside an issue body. Under the procedure, any discovery of exposed credentials or private data requires immediate containment (such as switching the Hugging Face repository to private and revoking the token), scrubbing the affected record, and reporting the incident to Security and the Data Protection Officer (or lecturer) within 2 hours so it can be assessed under the Notifiable Data Breaches scheme.

Risks, corrective actions and future mitigation

During my audit of the collection notebook and published table, I identified six technical and compliance risks and set out concrete corrective actions:

1. Duplicate records from zero indexed pagination: In fetch_issues(), my loop used for page in tqdm(range(num_pages)):, which starts at page=0 and ends at page=49. Because the GitHub REST API uses 1 based indexing, page=0 and page=1 return the exact same first 100 issues (numbers 8858 down to 8759), duplicating rows 0 to 99 in rows 100 to 199 and leaving 4,900 unique records. Corrective action: Change the collection loop to for page in tqdm(range(1, num_pages + 1)): and run drop_duplicates(subset="number") before model training or FAISS indexing.
2. Unnecessary personal identifiers in the raw schema: The published table keeps the full raw JSON structure, including user, assignee, assignees, closed_by, and milestone creator dictionaries that hold contributor usernames, numeric IDs, and avatar URLs. Corrective action: Use issues_dataset.remove_columns() to strip all nested user profile objects and keep only the required technical fields (html_url, title, body, comments, author_association, and is_pull_request).
3. Accidental personal details or credentials inside issue body text and empty bodies: Contributors pasting error logs into the body column sometimes leave local file paths containing real names (such as /Users/firstname_lastname/...), email addresses, IPv4 addresses, or tokens, and 385 rows (7.7 percent, including row 1, pull request 8857) have body: None. Corrective action: Filter out rows where body is None (issues_dataset.filter(lambda x: x["body"] is not None)) and apply a regular expression cleaning function via .map() to mask email addresses, IPv4 addresses, tokens, and local user directory paths before generating public embeddings.
4. Mixed pull requests and missing comment text: The GitHub /issues endpoint returns both bug issues and pull requests (2,878 rows or 57.6 percent are pull requests), and the comments field only provides the integer comment count rather than the discussion text. Corrective action: Filter with issues_dataset.filter(lambda x: x["is_pull_request"] == False) when searching specifically for user bug reports, and either fetch comment text from comments_url or concatenate title and body for semantic search.
5. Unclear contributor licensing and overseas hosting: Because issue text was written by many community contributors and the repository is stored on Hugging Face servers in the United States, republishing full raw records raises copyright and cross border storage questions. Corrective action: Act immediately on any contributor removal request submitted through the repository Community tab, and remove personal profile fields so that overseas storage holds only technical issue descriptions.
6. Token and account misuse if credentials leak: If a GitHub, Kaggle, or Hugging Face token were leaked, an unauthorised user could push changes or exhaust API quotas. Corrective action: Keep all tokens exclusively in Kaggle Secrets, delete the GitHub personal access token when the assessment ends, and keep multi factor authentication enabled across my GitHub, Kaggle, and Hugging Face accounts.

Storage, locations and versioning

All project files, datasets, and outputs are stored and tracked in line with Koorliny Kaatijin organisational policies: Public Cloud Dataset Location: This dataset and card are stored in the public Hugging Face dataset repository https://huggingface.co/datasets/drcoolio/github-clean, which holds data/train-00000-of-00001.parquet (4,663,700 bytes / 4.67 MB, 5,000 rows, stored with Git LFS), README.md, and .gitattributes. Notebooks and Assessment Files Storage: Copies of my notebooks, this Dataset Card, and my working notes are stored securely in my North Metropolitan TAFE OneDrive folder (/OneDrive/NMTAFE_ICT40120/Analyse & Report Data) with institutional role based access control and multi factor authentication enabled: Task 1 Notebook: session-9-creating-your-own-dataset.ipynb Task 2 Notebook: working-with-the-model-and-tokenizer.ipynb Task 3 Notebook: semantic-search-with-faiss.ipynb Credentials Storage: Both my GitHub token and my Hugging Face write token are stored in Kaggle Secrets and are not saved in any notebook or local file. I own the repository as the data owner, and the retention schedule is set out in the Data Retention and Disposal Policy section above. Repository Commit History and Planned Updates: 20 October 2026 (Initial Dataset Upload): Uploaded the 5,000 row Parquet table with 37 columns and generated metadata to drcoolio/github-clean under Git commit 7589747a041bb064d1f5581de2dc6c5984815722 with the commit message "Upload dataset". Documentation Update (README Dataset Card): Added this complete Dataset Card to README.md in drcoolio/github-clean covering dataset structure, reliability checks, privacy legislation, Koorliny Kaatijin policy alignment, and risk mitigation. The underlying Parquet data is unchanged. Planned Cleaned Upload (Preprocessing Pipeline): Deduplicated on number to 4,900 unique records, filtered to remove None bodies and pull requests as needed, and stripped of nested contributor profile columns for downstream Transformer pipeline and FAISS indexing.

Licence, attribution and permitted use

The repository metadata sets license: other. While the huggingface/datasets source code repository is published under the Apache License 2.0, that licence covers the software repository as published by its maintainers, whereas the issue and pull request text was written by many individual contributors whose separate permission I have not requested. Please use this dataset for educational learning and research. Keep the html_url column intact so every record can be traced and credited to its original author on GitHub, credit GitHub and the huggingface/datasets community as the source, and do not use the contributor profile fields for profiling or unsolicited contact.

Citation

Ahmed, F. D. (2026). GitHub Clean Issues [Data set]. Hugging Face. https://huggingface.co/datasets/drcoolio/github-clean

References

Gebru, T., Morgenstern, J., Vecchione, B., Vaughan, J. W., Wallach, H., Daumé III, H., & Crawford, K. (2021). Datasheets for datasets. https://arxiv.org/abs/1803.09010 GitHub. (n.d.). GitHub Acceptable Use Policies. https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies GitHub. (n.d.). GitHub Terms of Service. https://docs.github.com/en/site-policy/github-terms/github-terms-of-service GitHub. (n.d.). Rate limits for the REST API. https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api GitHub. (n.d.). REST API endpoints for issues. https://docs.github.com/en/rest/issues/issues Government of Western Australia. (n.d.). Privacy and Responsible Information Sharing. https://www.wa.gov.au/government/privacy-and-responsible-information-sharing Hugging Face. (n.d.). Content policy. https://huggingface.co/content-guidelines Hugging Face. (n.d.). Creating your own dataset. In LLM course, chapter 5. https://huggingface.co/learn/llm-course/chapter5/5 Hugging Face. (n.d.). Dataset card template. https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/datasetcard_template.md Hugging Face. (n.d.). Dataset cards. https://huggingface.co/docs/hub/datasets-cards Hugging Face. (n.d.). How to contribute to Datasets. https://github.com/huggingface/datasets/blob/main/CONTRIBUTING.md Hugging Face. (n.d.). huggingface/datasets [Source code repository, Apache License 2.0]. https://github.com/huggingface/datasets Koorliny Kaatijin. (2025). Data Access and Classification Policy. Koorliny Kaatijin. Koorliny Kaatijin. (2025). Data Breach Response Procedure. Koorliny Kaatijin. Koorliny Kaatijin. (2025). Data Retention and Disposal Policy. Koorliny Kaatijin. Koorliny Kaatijin. (2025). Information Security and Acceptable Use Policy. Koorliny Kaatijin. Koorliny Kaatijin. (2025). Privacy Policy. Koorliny Kaatijin. Office of the Australian Information Commissioner. (n.d.). Australian Privacy Principles quick reference. https://www.oaic.gov.au/privacy/australian-privacy-principles/australian-privacy-principles-quick-reference Office of the Australian Information Commissioner. (n.d.). Notifiable Data Breaches. https://www.oaic.gov.au/privacy/notifiable-data-breaches Privacy Act 1988 (Cth). https://www.legislation.gov.au/C2004A03712/latest/text