def check_peer_review_progress(
assignment_names: Iterable[str],
teams: Iterable[plug.Team],
title_regex: str,
num_reviews: int,
api: plug.PlatformAPI,
) -> None:
"""Check which teams have opened peer review issues in their allotted
review repos
Args:
assignment_names: Names of assignments.
teams: An iterable of student teams.
title_regex: A regex to match against issue titles.
num_reviews: Amount of reviews each student is expected to have made.
api: An implementation of :py:class:`repobee_plug.PlatformAPI` used to
interface with the platform (e.g. GitHub or GitLab) instance.
"""
teams = list(teams)
reviews = collections.defaultdict(list)
review_team_names = [
plug.generate_review_team_name(team, assignment_name) for team in teams
for assignment_name in assignment_names
]
review_teams = progresswrappers.get_teams(review_team_names,
api,
desc="Processing review teams")
for review_team in review_teams:
repos = list(api.get_team_repos(review_team))
if len(repos) != 1:
plug.log.warning(
f"Expected {review_team.name} to have 1 associated "
f"repo, found {len(repos)}. "
f"Skipping...")
continue
reviewed_repo = repos[0]
expected_reviewers = set(review_team.members)
reviewing_teams = _extract_reviewing_teams(teams, expected_reviewers)
review_issue_authors = {
issue.author
for issue in api.get_repo_issues(reviewed_repo)
if re.match(title_regex, issue.title)
}
for team in reviewing_teams:
reviews[str(team)].append(
plug.Review(
repo=reviewed_repo.name,
done=any(
map(review_issue_authors.__contains__, team.members)),
))
plug.echo(
formatters.format_peer_review_progress_output(
reviews, [team.name for team in teams], num_reviews))
def _discover_repos(student_teams: List[plug.StudentTeam],
api: plug.PlatformAPI) -> Iterable[plug.StudentRepo]:
student_teams_dict = {t.name: t for t in student_teams}
fetched_teams = progresswrappers.get_teams(student_teams,
api,
desc="Discovering team repos")
for team in fetched_teams:
repos = api.get_team_repos(team)
yield from (plug.StudentRepo(
name=repo.name,
url=repo.url,
team=student_teams_dict[team.name],
) for repo in repos)
def assign_peer_reviews(
assignment_names: Iterable[str],
teams: Iterable[plug.StudentTeam],
num_reviews: int,
issue: Optional[plug.Issue],
double_blind_key: Optional[str],
api: plug.PlatformAPI,
) -> None:
"""Assign peer reviewers among the students to each student repo. Each
student is assigned to review num_reviews repos, and consequently, each
repo gets reviewed by num_reviews reviewers.
In practice, each student repo has a review team generated (called
<student-repo-name>-review), to which num_reviews _other_ students are
assigned. The team itself is given pull-access to the student repo, so
that reviewers can view code and open issues, but cannot modify the
contents of the repo.
Args:
assignment_names: Names of assginments.
teams: Team objects specifying student groups.
num_reviews: Amount of reviews each student should perform
(consequently, the amount of reviews of each repo)
issue: An issue with review instructions to be opened in the considered
repos.
double_blind_key: If provided, use key to make double-blind review
allocation.
api: An implementation of :py:class:`repobee_plug.PlatformAPI` used to
interface with the platform (e.g. GitHub or GitLab) instance.
"""
issue = issue or DEFAULT_REVIEW_ISSUE
expected_repo_names = set(plug.generate_repo_names(teams,
assignment_names))
fetched_teams = progresswrappers.get_teams(teams,
api,
desc="Fetching teams and repos")
team_repo_tuples = [(team, list(api.get_team_repos(team)))
for team in fetched_teams]
fetched_repos = list(
itertools.chain.from_iterable(repos for _, repos in team_repo_tuples))
fetched_repo_dict = {r.name: r for r in fetched_repos}
missing = expected_repo_names - fetched_repo_dict.keys()
if missing:
raise plug.NotFoundError(f"Can't find repos: {', '.join(missing)}")
if double_blind_key:
plug.log.info(f"Creating anonymous repos with key: {double_blind_key}")
fetched_repo_dict = _create_anonymized_repos(
[(team, _only_expected_repos(repos, expected_repo_names))
for team, repos in team_repo_tuples],
double_blind_key,
api,
)
allocations_for_output = []
for assignment_name in assignment_names:
plug.echo("Allocating reviews")
allocations = plug.manager.hook.generate_review_allocations(
teams=teams, num_reviews=num_reviews)
# adjust names of review teams
review_team_specs, reviewed_team_names = list(
zip(*[(
plug.StudentTeam(
members=alloc.review_team.members,
name=_review_team_name(
alloc.reviewed_team,
assignment_name,
key=double_blind_key,
),
),
alloc.reviewed_team,
) for alloc in allocations]))
review_teams = _repobee.command.teams.create_teams(
review_team_specs, plug.TeamPermission.PULL, api)
review_teams_progress = plug.cli.io.progress_bar(
review_teams,
desc="Creating review teams",
total=len(review_team_specs),
)
for review_team, reviewed_team_name in zip(review_teams_progress,
reviewed_team_names):
reviewed_repo = fetched_repo_dict[plug.generate_repo_name(
reviewed_team_name, assignment_name)]
review_teams_progress.write( # type: ignore
f"Assigning {' and '.join(review_team.members)} "
f"to review {reviewed_repo.name}")
api.assign_repo(review_team, reviewed_repo,
plug.TeamPermission.PULL)
api.create_issue(
issue.title,
issue.body,
reviewed_repo,
# It's not possible to assign users with read-access in Gitea
# FIXME redesign so Gitea does not require special handling
assignees=review_team.members
if not isinstance(api, _repobee.ext.gitea.GiteaAPI) else None,
)
allocations_for_output.append({
"reviewed_repo": {
"name": reviewed_repo.name,
"url": reviewed_repo.url,
},
"review_team": {
"name": review_team.name,
"members": review_team.members,
},
})
if featflags.is_feature_enabled(
featflags.FeatureFlag.REPOBEE_4_REVIEW_COMMANDS):
output = dict(allocations=allocations_for_output,
num_reviews=num_reviews)
pathlib.Path("review_allocations.json").write_text(
json.dumps(output, indent=4),
encoding=sys.getdefaultencoding(),
)