| """ |
| compute_interactions_for_SE4DE_repos.py |
| ----------------------------------------- |
| Computes the five interaction types from Table 4 of Das et al. (EASE 2022) |
| per repo, broken down by artifact type (commits / issues / pull_requests). |
| |
| Interaction types: |
| Contribution — author != committer on a commit |
| Maintenance — non-creator merged/closed an artifact |
| Process — creator interacted with a maintainer (proxy: artifact |
| closed/merged by someone else) |
| Review — commenter != creator (proxy: review events + inline comments) |
| Discussion — two non-creators commented on the same artifact (proxy: |
| review activity on PRs with >1 distinct reviewer) |
| |
| Lookup dicts are built from the smaller files (pr_reviews, issue_closers). |
| The larger files (commits, prs, issues) are streamed one row at a time. |
| |
| Reads: |
| ../Data/DE_all_commits_details.csv |
| ../Data/DE_all_pr_details.csv |
| ../Data/DE_all_pr_reviews_graphql.csv |
| ../Data/DE_all_issue_details.csv |
| ../Data/DE_all_issue_closers.csv |
| |
| Writes: |
| ../Data/DE_repo_interactions.csv |
| """ |
|
|
| import csv |
| import sys |
| from collections import defaultdict |
|
|
|
|
| def set_csv_field_size_limit(): |
| csv.field_size_limit(min(sys.maxsize, 10**7)) |
|
|
|
|
| def count_data_rows(csv_path): |
| """Count logical CSV records, not physical newlines.""" |
| set_csv_field_size_limit() |
| with open(csv_path, 'r', encoding='utf-8', newline='') as f: |
| return sum(1 for _ in csv.reader(f)) - 1 |
|
|
|
|
| def load_merger_lookup(pr_reviews_csv): |
| """ |
| Build (full_name, pr_number) -> (merger_login, num_reviewers, |
| num_review_events) from pr_reviews. Loaded fully — smaller file. |
| """ |
| set_csv_field_size_limit() |
| lookup = {} |
| with open(pr_reviews_csv, newline='', encoding='utf-8') as f: |
| for row in csv.DictReader(f): |
| full_name = row['full_name'].strip() |
| try: |
| pr_number = int(row['pr_number']) |
| except (ValueError, KeyError): |
| continue |
| try: |
| num_reviewers = int(row.get('num_reviewers', 0) or 0) |
| num_review_events = int(row.get('num_review_events', 0) or 0) |
| except ValueError: |
| num_reviewers, num_review_events = 0, 0 |
| lookup[(full_name, pr_number)] = ( |
| row.get('merger_login', '').strip(), |
| num_reviewers, |
| num_review_events, |
| ) |
| return lookup |
|
|
|
|
| def load_closer_lookup(issue_closers_csv): |
| """ |
| Build (full_name, issue_number) -> (opener_login, closer_login). |
| Loaded fully — lightweight columns. |
| """ |
| set_csv_field_size_limit() |
| lookup = {} |
| with open(issue_closers_csv, newline='', encoding='utf-8') as f: |
| for row in csv.DictReader(f): |
| full_name = row['full_name'].strip() |
| try: |
| issue_number = int(row['issue_number']) |
| except (ValueError, KeyError): |
| continue |
| lookup[(full_name, issue_number)] = ( |
| row.get('opener_login', '').strip(), |
| row.get('closer_login', '').strip(), |
| ) |
| return lookup |
|
|
|
|
| def iter_csv(csv_path): |
| """Stream rows from a CSV file one at a time.""" |
| set_csv_field_size_limit() |
| with open(csv_path, newline='', encoding='utf-8') as f: |
| yield from csv.DictReader(f) |
|
|
|
|
| if __name__ == '__main__': |
| commits_csv = '../Data/DE_all_commits_details.csv' |
| prs_csv = '../Data/DE_all_pr_details.csv' |
| pr_reviews_csv = '../Data/DE_all_pr_reviews_graphql.csv' |
| issues_csv = '../Data/DE_all_issue_details.csv' |
| closers_csv = '../Data/DE_all_issue_closers.csv' |
| output_csv = '../Data/DE_repo_interactions.csv' |
|
|
| print('Building merger lookup from pr_reviews ...') |
| merger_lookup = load_merger_lookup(pr_reviews_csv) |
| print(f' {len(merger_lookup):,} PR merger entries loaded.') |
|
|
| print('Building closer lookup from issue_closers ...') |
| closer_lookup = load_closer_lookup(closers_csv) |
| print(f' {len(closer_lookup):,} issue closer entries loaded.') |
|
|
| |
| counts = defaultdict(lambda: defaultdict(int)) |
|
|
| |
| print('Counting rows in commits file...') |
| total_commits = count_data_rows(commits_csv) |
| print(f' Streaming {total_commits:,} commit rows ...') |
|
|
| for idx, row in enumerate(iter_csv(commits_csv), 1): |
| if idx % 100_000 == 0: |
| print(f' {idx:,}/{total_commits:,} commits processed ...') |
|
|
| full_name = row.get('full_name', '').strip() |
| author = row.get('author_login', '').strip() |
| committer = row.get('committer_login', '').strip() |
|
|
| |
| if author and committer and author != committer: |
| counts[full_name]['contribution_commits'] += 1 |
|
|
| |
| print('Counting rows in pr_details file...') |
| total_prs = count_data_rows(prs_csv) |
| print(f' Streaming {total_prs:,} PR rows ...') |
|
|
| for idx, row in enumerate(iter_csv(prs_csv), 1): |
| if idx % 100_000 == 0: |
| print(f' {idx:,}/{total_prs:,} PRs processed ...') |
|
|
| full_name = row.get('full_name', '').strip() |
| try: |
| pr_number = int(row.get('pr_number', '')) |
| except ValueError: |
| continue |
| author = row.get('user_login', '').strip() |
| merged_at = row.get('merged_at', '').strip() |
| is_merged = bool(merged_at) |
|
|
| merger, num_reviewers, num_review_events = \ |
| merger_lookup.get((full_name, pr_number), ('', 0, 0)) |
|
|
| if is_merged and merger and author and merger != author: |
| |
| counts[full_name]['maintenance_prs'] += 1 |
| |
| counts[full_name]['process_prs'] += 1 |
|
|
| |
| counts[full_name]['review_prs'] += num_review_events |
|
|
| |
| if num_reviewers >= 2: |
| counts[full_name]['discussion_prs'] += num_review_events |
|
|
| |
| print('Counting rows in issue_details file...') |
| total_issues = count_data_rows(issues_csv) |
| print(f' Streaming {total_issues:,} issue rows ...') |
|
|
| for idx, row in enumerate(iter_csv(issues_csv), 1): |
| if idx % 100_000 == 0: |
| print(f' {idx:,}/{total_issues:,} issues processed ...') |
|
|
| full_name = row.get('full_name', '').strip() |
| try: |
| issue_number = int(row.get('issue_number', '')) |
| except ValueError: |
| continue |
| opener = row.get('user_login', '').strip() |
| state = row.get('state', '').strip() |
| try: |
| comment_count = int(row.get('comments', 0) or 0) |
| except ValueError: |
| comment_count = 0 |
|
|
| _, closer = closer_lookup.get((full_name, issue_number), ('', '')) |
|
|
| if state == 'closed' and closer and opener and closer != opener: |
| |
| counts[full_name]['maintenance_issues'] += 1 |
| |
| counts[full_name]['process_issues'] += 1 |
|
|
| |
| counts[full_name]['review_issues'] += comment_count |
|
|
| |
| if closer and closer != opener and comment_count > 0: |
| counts[full_name]['discussion_issues'] += comment_count |
|
|
| |
| all_repos = set(counts.keys()) |
| print(f'Writing {len(all_repos):,} repo records to {output_csv} ...') |
|
|
| fieldnames = [ |
| 'full_name', |
| 'contribution_commits', |
| 'maintenance_issues', 'process_issues', 'review_issues', 'discussion_issues', |
| 'maintenance_prs', 'process_prs', 'review_prs', 'discussion_prs', |
| ] |
|
|
| with open(output_csv, 'w', newline='', encoding='utf-8') as outfile: |
| writer = csv.DictWriter(outfile, fieldnames=fieldnames) |
| writer.writeheader() |
| for fn in sorted(all_repos): |
| c = counts[fn] |
| writer.writerow({ |
| 'full_name': fn, |
| 'contribution_commits': c['contribution_commits'], |
| 'maintenance_issues': c['maintenance_issues'], |
| 'process_issues': c['process_issues'], |
| 'review_issues': c['review_issues'], |
| 'discussion_issues': c['discussion_issues'], |
| 'maintenance_prs': c['maintenance_prs'], |
| 'process_prs': c['process_prs'], |
| 'review_prs': c['review_prs'], |
| 'discussion_prs': c['discussion_prs'], |
| }) |
|
|
| print(f'Done. Output: {output_csv}') |
|
|
