def open_issues_from_hook_results(
hook_results: Mapping[str, List[plug.Result]],
repos: Iterable[plug.StudentRepo],
api: plug.PlatformAPI,
) -> None:
"""Open all issues from the hook results in the given repos. Issues given
in the hook results that do not belong to the repos are ignored, and repos
provided without corresponding issues in the hook results have no effect.
Args:
hook_results: A hook results dictionary.
repos: Student repos to open issues in.
api: plug.PlatformAPI,
"""
url_to_repo = {repo.url: repo for repo in repos}
for repo_url, repo_data in hook_results["repos"][0].data.items():
if repo_url in url_to_repo and repo_data["issues"]:
repo = url_to_repo[repo_url]
platform_repo = api.get_repo(repo.name, repo.team.name)
for issue_data in repo_data["issues"].values():
issue = api.create_issue(issue_data["title"],
issue_data["body"], platform_repo)
msg = (
f"Opened issue {repo.name}/#{issue.number}-'{issue.title}'"
)
plug.echo(msg)
def callback(args: argparse.Namespace, api: plug.PlatformAPI) -> None:
repo_name_to_team: Mapping[str, plug.StudentTeam] = {
plug.generate_repo_name(student_team.name, assignment_name):
student_team
for student_team in args.students
for assignment_name in args.assignments
}
repo_names = list(repo_name_to_team.keys())
if "multi_issues_file" in args and args.multi_issues_file is not None:
issues_file = pathlib.Path(args.multi_issues_file).resolve()
all_issues = _parse_multi_issues_file(issues_file)
else:
issues_dir = pathlib.Path(args.issues_dir).resolve()
all_issues = _collect_issues(repo_names, issues_dir)
issues = _extract_expected_issues(all_issues, repo_names,
args.allow_missing)
for repo_name, issue in issues:
open_issue = args.batch_mode or _ask_for_open(issue, repo_name,
args.truncation_length)
if open_issue:
repo = api.get_repo(repo_name, repo_name_to_team[repo_name].name)
api.create_issue(issue.title, issue.body, repo)
else:
plug.echo("Skipping {}".format(repo_name))
def _get_issue_generator(
repos: Iterable[plug.StudentRepo],
title_regex: str,
author: Optional[str],
state: plug.IssueState,
double_blind_key: Optional[str],
api: plug.PlatformAPI,
) -> Iterable[Tuple[plug.StudentRepo, Iterable[plug.Issue]]]:
for repo in repos:
if double_blind_key:
team_name = _hash_if_key(repo.team.name, double_blind_key)
repo_name = _hash_if_key(repo.name, double_blind_key)
platform_repo = api.get_repo(repo_name, team_name)
else:
platform_repo = api.get_repo(repo.name, repo.team.name)
yield repo, [
issue for issue in api.get_repo_issues(platform_repo)
if re.match(title_regex, issue.title) and (
state == plug.IssueState.ALL or state == issue.state) and (
not author or issue.author == author)
]
def _create_or_fetch_repo(
name: str,
description: str,
private: bool,
api: plug.PlatformAPI,
team: Optional[plug.Team] = None,
) -> Tuple[bool, plug.Repo]:
try:
return (
True,
api.create_repo(
name, description=description, private=private, team=team
),
)
except plug.PlatformError:
team_name = team.name if team else None
repo = api.get_repo(repo_name=name, team_name=team_name)
if team:
api.assign_repo(
team=team, repo=repo, permission=plug.TeamPermission.PUSH
)
return False, repo