faf4208295
When there are more than 15 reviewers, the `set_assignee` script was adding the reviewers more or less on a random basis because the input set was arbitrarily ordered (thanks to how Python "set" works), and the attempt to add any reviewers beyond the count of 15 results in the previoulsy added reviewer being removed. This commit updates the `set_assignee` script such that: 1. The collaborator list (input for generating the reviewer list) is ordered by the area match, such that the collaborators of the most relevant area come first. 2. The reviewers of the relevant areas are added first, until the total reviewer count is 15. The script does not attempt to add more than 15 reviewers because that can result in the previously added reviewers being removed from the list. Signed-off-by: Stephanos Ioannidis <root@stephanos.io>
237 lines
7.6 KiB
Python
Executable file
237 lines
7.6 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
|
|
# Copyright (c) 2022 Intel Corp.
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
|
|
import argparse
|
|
import sys
|
|
import os
|
|
import time
|
|
import datetime
|
|
from github import Github, GithubException
|
|
from github.GithubException import UnknownObjectException
|
|
from collections import defaultdict
|
|
|
|
TOP_DIR = os.path.join(os.path.dirname(__file__))
|
|
sys.path.insert(0, os.path.join(TOP_DIR, "scripts"))
|
|
from get_maintainer import Maintainers
|
|
|
|
def log(s):
|
|
if args.verbose > 0:
|
|
print(s, file=sys.stdout)
|
|
|
|
def parse_args():
|
|
global args
|
|
parser = argparse.ArgumentParser(
|
|
description=__doc__,
|
|
formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
|
|
parser.add_argument("-M", "--maintainer-file", required=False, default="MAINTAINERS.yml",
|
|
help="Maintainer file to be used.")
|
|
parser.add_argument("-P", "--pull_request", required=False, default=None, type=int,
|
|
help="Operate on one pull-request only.")
|
|
parser.add_argument("-s", "--since", required=False,
|
|
help="Process pull-requests since date.")
|
|
|
|
parser.add_argument("-y", "--dry-run", action="store_true", default=False,
|
|
help="Dry run only.")
|
|
|
|
parser.add_argument("-o", "--org", default="zephyrproject-rtos",
|
|
help="Github organisation")
|
|
|
|
parser.add_argument("-r", "--repo", default="zephyr",
|
|
help="Github repository")
|
|
|
|
parser.add_argument("-v", "--verbose", action="count", default=0,
|
|
help="Verbose Output")
|
|
|
|
args = parser.parse_args()
|
|
|
|
def process_pr(gh, maintainer_file, number):
|
|
|
|
gh_repo = gh.get_repo(f"{args.org}/{args.repo}")
|
|
pr = gh_repo.get_pull(number)
|
|
|
|
log(f"working on https://github.com/{args.org}/{args.repo}/pull/{pr.number} : {pr.title}")
|
|
|
|
labels = set()
|
|
area_counter = defaultdict(int)
|
|
maint = defaultdict(int)
|
|
|
|
num_files = 0
|
|
all_areas = set()
|
|
fn = list(pr.get_files())
|
|
if len(fn) > 500:
|
|
log(f"Too many files changed ({len(fn)}), skipping....")
|
|
return
|
|
for f in pr.get_files():
|
|
num_files += 1
|
|
log(f"file: {f.filename}")
|
|
areas = maintainer_file.path2areas(f.filename)
|
|
|
|
if areas:
|
|
all_areas.update(areas)
|
|
for a in areas:
|
|
area_counter[a.name] += 1
|
|
labels.update(a.labels)
|
|
for p in a.maintainers:
|
|
maint[p] += 1
|
|
|
|
ac = dict(sorted(area_counter.items(), key=lambda item: item[1], reverse=True))
|
|
log(f"Area matches: {ac}")
|
|
log(f"labels: {labels}")
|
|
if len(labels) > 10:
|
|
log(f"Too many labels to be applied")
|
|
return
|
|
|
|
# Create a list of collaborators ordered by the area match
|
|
collab = list()
|
|
for a in ac:
|
|
collab += maintainer_file.areas[a].maintainers
|
|
collab += maintainer_file.areas[a].collaborators
|
|
collab = list(dict.fromkeys(collab))
|
|
log(f"collab: {collab}")
|
|
|
|
sm = dict(sorted(maint.items(), key=lambda item: item[1], reverse=True))
|
|
|
|
log(f"Submitted by: {pr.user.login}")
|
|
log(f"candidate maintainers: {sm}")
|
|
|
|
maintainer = "None"
|
|
maintainers = list(sm.keys())
|
|
|
|
prop = 0
|
|
if maintainers:
|
|
maintainer = maintainers[0]
|
|
|
|
if len(ac) > 1 and list(ac.values())[0] == list(ac.values())[1]:
|
|
for aa in ac:
|
|
if 'Documentation' in aa:
|
|
log("++ With multiple areas of same weight including docs, take something else other than Documentation as the maintainer")
|
|
for a in all_areas:
|
|
if (a.name == aa and
|
|
a.maintainers and a.maintainers[0] == maintainer and
|
|
len(maintainers) > 1):
|
|
maintainer = maintainers[1]
|
|
elif 'Platform' in aa:
|
|
log("++ Platform takes precedence over subsystem...")
|
|
log(f"Set maintainer of area {aa}")
|
|
for a in all_areas:
|
|
if a.name == aa:
|
|
if a.maintainers:
|
|
maintainer = a.maintainers[0]
|
|
break
|
|
|
|
|
|
# if the submitter is the same as the maintainer, check if we have
|
|
# multiple maintainers
|
|
if pr.user.login == maintainer:
|
|
log("Submitter is same as Assignee, trying to find another assignee...")
|
|
aff = list(ac.keys())[0]
|
|
for a in all_areas:
|
|
if a.name == aff:
|
|
if len(a.maintainers) > 1:
|
|
maintainer = a.maintainers[1]
|
|
else:
|
|
log(f"This area has only one maintainer, keeping assignee as {maintainer}")
|
|
|
|
prop = (maint[maintainer] / num_files) * 100
|
|
if prop < 20:
|
|
maintainer = "None"
|
|
|
|
log(f"Picked maintainer: {maintainer} ({prop:.2f}% ownership)")
|
|
log("+++++++++++++++++++++++++")
|
|
|
|
# Set labels
|
|
if labels and len(labels) < 10:
|
|
for l in labels:
|
|
log(f"adding label {l}...")
|
|
if not args.dry_run:
|
|
pr.add_to_labels(l)
|
|
|
|
if collab:
|
|
reviewers = []
|
|
existing_reviewers = set()
|
|
|
|
revs = pr.get_reviews()
|
|
for review in revs:
|
|
existing_reviewers.add(review.user)
|
|
|
|
rl = pr.get_review_requests()
|
|
page = 0
|
|
for r in rl:
|
|
existing_reviewers |= set(r.get_page(page))
|
|
page += 1
|
|
|
|
for c in collab:
|
|
try:
|
|
u = gh.get_user(c)
|
|
if pr.user != u and gh_repo.has_in_collaborators(u):
|
|
if u not in existing_reviewers:
|
|
reviewers.append(c)
|
|
except UnknownObjectException as e:
|
|
log(f"Can't get user '{c}', account does not exist anymore? ({e})")
|
|
|
|
if len(existing_reviewers) < 15:
|
|
reviewer_vacancy = 15 - len(existing_reviewers)
|
|
reviewers = reviewers[:reviewer_vacancy]
|
|
|
|
if reviewers:
|
|
try:
|
|
log(f"adding reviewers {reviewers}...")
|
|
if not args.dry_run:
|
|
pr.create_review_request(reviewers=reviewers)
|
|
except GithubException:
|
|
log("cant add reviewer")
|
|
else:
|
|
log("not adding reviewers because the existing reviewer count is greater than or "
|
|
"equal to 15")
|
|
|
|
ms = []
|
|
# assignees
|
|
if maintainer != 'None' and not pr.assignee:
|
|
try:
|
|
u = gh.get_user(maintainer)
|
|
ms.append(u)
|
|
except GithubException:
|
|
log(f"Error: Unknown user")
|
|
|
|
for mm in ms:
|
|
log(f"Adding assignee {mm}...")
|
|
if not args.dry_run:
|
|
pr.add_to_assignees(mm)
|
|
else:
|
|
log("not setting assignee")
|
|
|
|
time.sleep(1)
|
|
|
|
def main():
|
|
parse_args()
|
|
|
|
token = os.environ.get('GITHUB_TOKEN', None)
|
|
if not token:
|
|
sys.exit('Github token not set in environment, please set the '
|
|
'GITHUB_TOKEN environment variable and retry.')
|
|
|
|
gh = Github(token)
|
|
maintainer_file = Maintainers(args.maintainer_file)
|
|
|
|
if args.pull_request:
|
|
process_pr(gh, maintainer_file, args.pull_request)
|
|
else:
|
|
if args.since:
|
|
since = args.since
|
|
else:
|
|
today = datetime.date.today()
|
|
since = today - datetime.timedelta(days=1)
|
|
|
|
common_prs = f'repo:{args.org}/{args.repo} is:open is:pr base:main -is:draft no:assignee created:>{since}'
|
|
pulls = gh.search_issues(query=f'{common_prs}')
|
|
|
|
for issue in pulls:
|
|
process_pr(gh, maintainer_file, issue.number)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|