[github] Fix minor lint warnings (NFC)

llvm/utils/git/github-automation.py

 import argparse
 from git import Repo # type: ignore
 import github
 import os
 import re
 import requests
 import sys
 import time
-from typing import *
+from typing import List, Optional
 
 class IssueSubscriber:
 
     @property
     def team_name(self) -> str:
         return self._team_name
 
     def __init__(self, token:str, repo:str, issue_number:int, label_name:str):
def phab_api_call(phab_token:str, url:str, args:dict) -> dict:
     containing the json response.
     """
     data = { "api.token" : phab_token }
     data.update(args)
     response = requests.post(url, data = data)
     return response.json()
 
 
-def phab_login_to_github_login(phab_token:str, repo:github.Repository.Repository, phab_login:str) -> str:
+def phab_login_to_github_login(phab_token:str, repo:github.Repository.Repository, phab_login:str) -> Optional[str]:
     """
     Tries to translate a Phabricator login to a github login by
     finding a commit made in Phabricator's Differential.
     The commit's SHA1 is then looked up in the github repo and
     the committer's login associated with that commit is returned.
 
     :param str phab_token: The Conduit API token to use for communication with Pabricator
     :param github.Repository.Repository repo: The github repo to use when looking for the SHA1 found in Differential
def phab_login_to_github_login(phab_token:str, repo:github.Repository.Repository, phab_login:str) -> Optional[str]:
     committer = repo.get_commit(commit_sha).committer
     if not committer:
         # This committer had an email address GitHub could not recognize, so
         # it can't link the user to a GitHub account.
         print(f"Warning: Can't find github account for {phab_login}")
         return None
     return committer.login
 
-def phab_get_commit_approvers(phab_token:str, repo:github.Repository.Repository, commit:github.Commit.Commit) -> list:
+def phab_get_commit_approvers(phab_token:str, commit:github.Commit.Commit) -> list:
     args = { "corpus" : commit.commit.message }
     # API documentation: https://reviews.llvm.org/conduit/method/differential.parsecommitmessage/
     r = phab_api_call(phab_token, "https://reviews.llvm.org/api/differential.parsecommitmessage", args)
     review_id = r['result']['revisionIDFieldInfo']['value']
     if not review_id:
         # No Phabricator revision for this commit
         return []
 
def pr_request_review(self, pr:github.PullRequest.PullRequest):
         then add a comment requesting review of the backport and assign the
         pull request to the selected reviewers.
 
         The reviewers selected are those users who approved the patch in
         Phabricator.
         """
         reviewers = []
         for commit in pr.get_commits():
-            approvers = phab_get_commit_approvers(self.phab_token, self.repo, commit)
+            approvers = phab_get_commit_approvers(self.phab_token, commit)
             for a in approvers:
                 login = phab_login_to_github_login(self.phab_token, self.repo, a)
                 if not login:
                     continue
                 reviewers.append(login)
         if len(reviewers):
             message = "{} What do you think about merging this PR to the release branch?".format(
                     " ".join(["@" + r for r in reviewers]))
def create_pull_request(self, owner:str, repo_name:str, branch:str) -> bool:
         head_branch = branch
         if not repo.fork:
             # If the target repo is not a fork of llvm-project, we need to copy
             # the branch into the target repo.  GitHub only supports cross-repo pull
             # requests on forked repos.
             head_branch = f'{owner}-{branch}'
             local_repo = Repo(self.llvm_project_dir)
             push_done = False
-            for i in range(0,5):
+            for _ in range(0,5):
                 try:
                     local_repo.git.fetch(f'https://github.com/{owner}/{repo_name}', f'{branch}:{branch}')
                     local_repo.git.push(self.push_url, f'{branch}:{head_branch}', force=True)
                     push_done = True
                     break
                 except Exception as e:
                     print(e)
                     time.sleep(30)
def execute_command(self) -> bool:
         """
         This function reads lines from STDIN and executes the first command
         that it finds.  The 2 supported commands are:
         /cherry-pick commit0 <commit1> <commit2> <...>
         /branch <owner>/<repo>/<branch>
         """
         for line in sys.stdin:
             line.rstrip()
-            m = re.search("/([a-z-]+)\s(.+)", line)
+            m = re.search(r"/([a-z-]+)\s(.+)", line)
             if not m:
                 continue
             command = m.group(1)
             args = m.group(2)
 
             if command == 'cherry-pick':
                 return self.create_branch(args.split())
 

llvm/utils/git/pre-push.py

From the git doc:
   The pre-push hook runs during git push, after the remote refs have been
   updated but before any objects have been transferred. It receives the name
   and location of the remote as parameters, and a list of to-be-updated refs
   through stdin. You can use it to validate a set of ref updates before a push
   occurs (a non-zero exit code will abort the push).
 """
 
 import argparse
-import collections
 import os
-import re
 import shutil
 import subprocess
 import sys
 import time
-import getpass
 from shlex import quote
 
 VERBOSE = False
 QUIET = False
 dev_null_fd = None
 z40 = '0000000000000000000000000000000000000000'