blob: d20919315859212bd86ea7f307ab4a81586c8a8d [file] [log] [blame]
#!/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
from west.manifest import Manifest
from west.manifest import ManifestProject
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, allow_abbrev=False)
parser.add_argument("-M", "--maintainer-file", required=False, default="MAINTAINERS.yml",
help="Maintainer file to be used.")
group = parser.add_mutually_exclusive_group()
group.add_argument("-P", "--pull_request", required=False, default=None, type=int,
help="Operate on one pull-request only.")
group.add_argument("-I", "--issue", required=False, default=None, type=int,
help="Operate on one issue only.")
group.add_argument("-s", "--since", required=False,
help="Process pull-requests since date.")
group.add_argument("-m", "--modules", action="store_true",
help="Process pull-requests from modules.")
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)
found_maintainers = defaultdict(int)
num_files = 0
all_areas = set()
fn = list(pr.get_files())
manifest_change = False
for changed_file in fn:
if changed_file.filename in ['west.yml','submanifests/optional.yaml']:
manifest_change = True
break
# one liner PRs should be trivial
if pr.commits == 1 and (pr.additions <= 1 and pr.deletions <= 1) and not manifest_change:
labels = {'Trivial'}
if len(fn) > 500:
log(f"Too many files changed ({len(fn)}), skipping....")
return
for changed_file in fn:
num_files += 1
log(f"file: {changed_file.filename}")
areas = maintainer_file.path2areas(changed_file.filename)
if not areas:
continue
all_areas.update(areas)
is_instance = False
sorted_areas = sorted(areas, key=lambda x: 'Platform' in x.name, reverse=True)
for area in sorted_areas:
c = 1 if not is_instance else 0
area_counter[area] += c
labels.update(area.labels)
# FIXME: Here we count the same file multiple times if it exists in
# multiple areas with same maintainer
for area_maintainer in area.maintainers:
found_maintainers[area_maintainer] += c
if 'Platform' in area.name:
is_instance = True
area_counter = dict(sorted(area_counter.items(), key=lambda item: item[1], reverse=True))
log(f"Area matches: {area_counter}")
log(f"labels: {labels}")
# Create a list of collaborators ordered by the area match
collab = list()
for area in area_counter:
collab += maintainer_file.areas[area.name].maintainers
collab += maintainer_file.areas[area.name].collaborators
collab = list(dict.fromkeys(collab))
log(f"collab: {collab}")
_all_maintainers = dict(sorted(found_maintainers.items(), key=lambda item: item[1], reverse=True))
log(f"Submitted by: {pr.user.login}")
log(f"candidate maintainers: {_all_maintainers}")
maintainers = list(_all_maintainers.keys())
assignee = None
# we start with areas with most files changed and pick the maintainer from the first one.
# if the first area is an implementation, i.e. driver or platform, we
# continue searching for any other areas
for area, count in area_counter.items():
if count == 0:
continue
if len(area.maintainers) > 0:
assignee = area.maintainers[0]
if 'Platform' not in area.name:
break
# if the submitter is the same as the maintainer, check if we have
# multiple maintainers
if len(maintainers) > 1 and pr.user.login == assignee:
log("Submitter is same as Assignee, trying to find another assignee...")
aff = list(area_counter.keys())[0]
for area in all_areas:
if area == aff:
if len(area.maintainers) > 1:
assignee = area.maintainers[1]
else:
log(f"This area has only one maintainer, keeping assignee as {assignee}")
if assignee:
prop = (found_maintainers[assignee] / num_files) * 100
log(f"Picked assignee: {assignee} ({prop:.2f}% ownership)")
log("+++++++++++++++++++++++++")
# Set labels
if labels:
if len(labels) < 10:
for l in labels:
log(f"adding label {l}...")
if not args.dry_run:
pr.add_to_labels(l)
else:
log(f"Too many labels to be applied")
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
# check for reviewers that remove themselves from list of reviewer and
# do not attempt to add them again based on MAINTAINERS file.
self_removal = []
for event in pr.get_issue_events():
if event.event == 'review_request_removed' and event.actor == event.requested_reviewer:
self_removal.append(event.actor)
for collaborator in collab:
try:
gh_user = gh.get_user(collaborator)
if pr.user == gh_user or gh_user in existing_reviewers:
continue
if not gh_repo.has_in_collaborators(gh_user):
log(f"Skip '{collaborator}': not in collaborators")
continue
if gh_user in self_removal:
log(f"Skip '{collaborator}': self removed")
continue
reviewers.append(collaborator)
except UnknownObjectException as e:
log(f"Can't get user '{collaborator}', 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 assignee and not pr.assignee:
try:
u = gh.get_user(assignee)
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 process_issue(gh, maintainer_file, number):
gh_repo = gh.get_repo(f"{args.org}/{args.repo}")
issue = gh_repo.get_issue(number)
log(f"Working on {issue.url}: {issue.title}")
if issue.assignees:
print(f"Already assigned {issue.assignees}, bailing out")
return
label_to_maintainer = defaultdict(set)
for _, area in maintainer_file.areas.items():
if not area.labels:
continue
labels = set()
for label in area.labels:
labels.add(label.lower())
labels = tuple(sorted(labels))
for maintainer in area.maintainers:
label_to_maintainer[labels].add(maintainer)
# Add extra entries for areas with multiple labels so they match with just
# one label if it's specific enough.
for areas, maintainers in dict(label_to_maintainer).items():
for area in areas:
if tuple([area]) not in label_to_maintainer:
label_to_maintainer[tuple([area])] = maintainers
issue_labels = set()
for label in issue.labels:
label_name = label.name.lower()
if tuple([label_name]) not in label_to_maintainer:
print(f"Ignoring label: {label}")
continue
issue_labels.add(label_name)
issue_labels = tuple(sorted(issue_labels))
print(f"Using labels: {issue_labels}")
if issue_labels not in label_to_maintainer:
print(f"no match for the label set, not assigning")
return
for maintainer in label_to_maintainer[issue_labels]:
log(f"Adding {maintainer} to {issue.html_url}")
if not args.dry_run:
issue.add_to_assignees(maintainer)
def process_modules(gh, maintainers_file):
manifest = Manifest.from_file()
repos = {}
for project in manifest.get_projects([]):
if not manifest.is_active(project):
continue
if isinstance(project, ManifestProject):
continue
area = f"West project: {project.name}"
if area not in maintainers_file.areas:
log(f"No area for: {area}")
continue
maintainers = maintainers_file.areas[area].maintainers
if not maintainers:
log(f"No maintainers for: {area}")
continue
collaborators = maintainers_file.areas[area].collaborators
log(f"Found {area}, maintainers={maintainers}, collaborators={collaborators}")
repo_name = f"{args.org}/{project.name}"
repos[repo_name] = maintainers_file.areas[area]
query = f"is:open is:pr no:assignee"
for repo in repos:
query += f" repo:{repo}"
issues = gh.search_issues(query=query)
for issue in issues:
pull = issue.as_pull_request()
if pull.draft:
continue
if pull.assignees:
log(f"ERROR: {pull.html_url} should have no assignees, found {pull.assignees}")
continue
repo_name = f"{args.org}/{issue.repository.name}"
area = repos[repo_name]
for maintainer in area.maintainers:
log(f"Assigning {maintainer} to {pull.html_url}")
if not args.dry_run:
pull.add_to_assignees(maintainer)
pull.create_review_request(maintainer)
for collaborator in area.collaborators:
log(f"Adding {collaborator} to {pull.html_url}")
if not args.dry_run:
pull.create_review_request(collaborator)
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)
elif args.issue:
process_issue(gh, maintainer_file, args.issue)
elif args.modules:
process_modules(gh, maintainer_file)
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()