Resurrect top-ranking issues script (#25433)

Release Notes:

- N/A

script/update_top_ranking_issues/main.py

@@ -0,0 +1,215 @@
+import os
+from collections import defaultdict
+from datetime import datetime, timedelta
+from typing import Optional
+
+import typer
+from github import Github
+from github.Issue import Issue
+from github.Repository import Repository
+from pytz import timezone
+from typer import Typer
+
+app: Typer = typer.Typer()
+
+DATETIME_FORMAT: str = "%m/%d/%Y %I:%M %p"
+ISSUES_PER_LABEL: int = 50
+
+
+class IssueData:
+    def __init__(self, issue: Issue) -> None:
+        self.title = issue.title
+        self.url: str = issue.html_url
+        self.like_count: int = issue._rawData["reactions"]["+1"]  # type: ignore [attr-defined]
+        self.creation_datetime: str = issue.created_at.strftime(DATETIME_FORMAT)
+        # TODO: Change script to support storing labels here, rather than directly in the script
+        self.labels: set[str] = {label["name"] for label in issue._rawData["labels"]}  # type: ignore [attr-defined]
+        self._issue = issue
+
+
+@app.command()
+def main(
+    github_token: Optional[str] = None,
+    issue_reference_number: Optional[int] = None,
+    query_day_interval: Optional[int] = None,
+) -> None:
+    start_time: datetime = datetime.now()
+
+    start_date: datetime | None = None
+
+    if query_day_interval:
+        tz = timezone("america/new_york")
+        current_time = datetime.now(tz).replace(
+            hour=0, minute=0, second=0, microsecond=0
+        )
+        start_date = current_time - timedelta(days=query_day_interval)
+
+    # GitHub Workflow will pass in the token as an environment variable,
+    # but we can place it in our env when running the script locally, for convenience
+    github_token = github_token or os.getenv("GITHUB_ACCESS_TOKEN")
+    github = Github(github_token)
+
+    remaining_requests_before: int = github.rate_limiting[0]
+    print(f"Remaining requests before: {remaining_requests_before}")
+
+    repo_name: str = "zed-industries/zed"
+    repository: Repository = github.get_repo(repo_name)
+
+    label_to_issue_data: dict[str, list[IssueData]] = get_issue_maps(
+        github, repository, start_date
+    )
+
+    issue_text: str = get_issue_text(label_to_issue_data)
+
+    if issue_reference_number:
+        top_ranking_issues_issue: Issue = repository.get_issue(issue_reference_number)
+        top_ranking_issues_issue.edit(body=issue_text)
+    else:
+        print(issue_text)
+
+    remaining_requests_after: int = github.rate_limiting[0]
+    print(f"Remaining requests after: {remaining_requests_after}")
+    print(f"Requests used: {remaining_requests_before - remaining_requests_after}")
+
+    run_duration: timedelta = datetime.now() - start_time
+    print(run_duration)
+
+
+def get_issue_maps(
+    github: Github,
+    repository: Repository,
+    start_date: datetime | None = None,
+) -> dict[str, list[IssueData]]:
+    label_to_issues: defaultdict[str, list[Issue]] = get_label_to_issues(
+        github,
+        repository,
+        start_date,
+    )
+    label_to_issue_data: dict[str, list[IssueData]] = get_label_to_issue_data(
+        label_to_issues
+    )
+
+    # Create a new dictionary with labels ordered by the summation the of likes on the associated issues
+    labels = list(label_to_issue_data.keys())
+
+    labels.sort(
+        key=lambda label: sum(
+            issue_data.like_count for issue_data in label_to_issue_data[label]
+        ),
+        reverse=True,
+    )
+
+    label_to_issue_data = {label: label_to_issue_data[label] for label in labels}
+
+    return label_to_issue_data
+
+
+def get_label_to_issues(
+    github: Github,
+    repository: Repository,
+    start_date: datetime | None = None,
+) -> defaultdict[str, list[Issue]]:
+    common_filters = [
+        f"repo:{repository.full_name}",
+        "is:open",
+        "is:issue",
+        '-label:"ignore top-ranking issues"',
+        "sort:reactions-+1-desc",
+    ]
+
+    date_query: str | None = (
+        f"created:>={start_date.strftime('%Y-%m-%d')}" if start_date else None
+    )
+
+    if date_query:
+        common_filters.append(date_query)
+
+    common_filter_string = " ".join(common_filters)
+
+    section_queries = {
+        "bug": "label:bug,type:Bug",
+        "crash": "label:crash,type:Crash",
+        "feature": "label:feature",
+        "meta": "type:Meta",
+        "unlabeled": "no:label no:type",
+    }
+
+    label_to_issues: defaultdict[str, list[Issue]] = defaultdict(list)
+
+    for section, section_query in section_queries.items():
+        label_query: str = f"{common_filter_string} {section_query}"
+
+        issues = github.search_issues(label_query)
+
+        if issues.totalCount > 0:
+            for issue in issues[0:ISSUES_PER_LABEL]:
+                label_to_issues[section].append(issue)
+
+    return label_to_issues
+
+
+def get_label_to_issue_data(
+    label_to_issues: defaultdict[str, list[Issue]],
+) -> dict[str, list[IssueData]]:
+    label_to_issue_data: dict[str, list[IssueData]] = {}
+
+    for label in label_to_issues:
+        issues: list[Issue] = label_to_issues[label]
+        issue_data: list[IssueData] = [IssueData(issue) for issue in issues]
+        issue_data.sort(
+            key=lambda issue_data: (
+                -issue_data.like_count,
+                issue_data.creation_datetime,
+            )
+        )
+
+        if issue_data:
+            label_to_issue_data[label] = issue_data
+
+    return label_to_issue_data
+
+
+def get_issue_text(
+    label_to_issue_data: dict[str, list[IssueData]],
+) -> str:
+    tz = timezone("america/new_york")
+    current_datetime: str = datetime.now(tz).strftime(f"{DATETIME_FORMAT} (%Z)")
+
+    highest_ranking_issues_lines: list[str] = get_highest_ranking_issues_lines(
+        label_to_issue_data
+    )
+
+    issue_text_lines: list[str] = [
+        f"*Updated on {current_datetime}*",
+        *highest_ranking_issues_lines,
+        "\n---\n",
+        "*For details on how this issue is generated, [see the script](https://github.com/zed-industries/zed/blob/main/script/update_top_ranking_issues/main.py)*",
+    ]
+
+    return "\n".join(issue_text_lines)
+
+
+def get_highest_ranking_issues_lines(
+    label_to_issue_data: dict[str, list[IssueData]],
+) -> list[str]:
+    highest_ranking_issues_lines: list[str] = []
+
+    if label_to_issue_data:
+        for label, issue_data in label_to_issue_data.items():
+            highest_ranking_issues_lines.append(f"\n## {label}\n")
+
+            for i, issue_data in enumerate(issue_data):
+                markdown_bullet_point: str = (
+                    f"{issue_data.url} ({issue_data.like_count} :thumbsup:)"
+                )
+
+                markdown_bullet_point = f"{i + 1}. {markdown_bullet_point}"
+                highest_ranking_issues_lines.append(markdown_bullet_point)
+
+    return highest_ranking_issues_lines
+
+
+if __name__ == "__main__":
+    app()
+
+# TODO: Sort label output into core and non core sections