ghstack 0.14.0__tar.gz → 0.15.0__tar.gz

{ghstack-0.14.0 → ghstack-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ghstack
-Version: 0.14.0
+Version: 0.15.0
 Summary: Stack diff support for GitHub
 Author: Edward Z. Yang
 Author-email: Edward Z. Yang <ezyang@mit.edu>

{ghstack-0.14.0 → ghstack-0.15.0}/pyproject.toml

@@ -16,7 +16,7 @@ dependencies = [
     "flake8<8.0.0,>=7.0.0",
 ]
 name = "ghstack"
-version = "0.14.0"
+version = "0.15.0"
 description = "Stack diff support for GitHub"
 readme = "README.md"
 classifiers = [

{ghstack-0.14.0 → ghstack-0.15.0}/src/ghstack/checkout.py

@@ -52,6 +52,8 @@ def main(
 
     # If --same-base is specified, check what the new merge-base would be
     if same_base:
+        assert default_branch_ref is not None
+        assert current_base is not None
         target_ref = remote_name + "/" + orig_ref
         new_base = sh.git("merge-base", default_branch_ref, target_ref)
 

{ghstack-0.14.0 → ghstack-0.15.0}/src/ghstack/cherry_pick.py

@@ -14,6 +14,7 @@ def main(
     sh: ghstack.shell.Shell,
     remote_name: str,
     stack: bool = False,
+    no_fetch: bool = False,
 ) -> None:
 
     params = ghstack.github_utils.parse_pull_request(
@@ -26,7 +27,8 @@ def main(
             "The ref {} doesn't look like a ghstack reference".format(head_ref)
         )
 
-    sh.git("fetch", "--prune", remote_name)
+    if not no_fetch:
+        sh.git("fetch", "--prune", remote_name)
 
     if stack:
         # Cherry-pick the entire stack from merge-base to the commit

{ghstack-0.14.0 → ghstack-0.15.0}/src/ghstack/cli.py

@@ -13,6 +13,7 @@ import ghstack.circleci_real
 import ghstack.config
 import ghstack.github_real
 import ghstack.land
+import ghstack.log
 import ghstack.logs
 import ghstack.rage
 import ghstack.status
@@ -48,22 +49,74 @@ def cli_context(
         yield shell, config, github
 
 
-@click.group(invoke_without_command=True)
+@click.group(
+    invoke_without_command=True,
+    epilog="Running ghstack with no subcommand is equivalent to ghstack submit.",
+)
 @click.pass_context
 @click.version_option(ghstack.__version__, "--version", "-V")
 @click.option("--debug", is_flag=True, help="Log debug information to stderr")
-# hidden arguments that we'll pass along to submit if no other command given
-@click.option("--message", "-m", default="Update", hidden=True)
-@click.option("--update-fields", "-u", is_flag=True, hidden=True)
-@click.option("--short", is_flag=True, hidden=True)
-@click.option("--force", is_flag=True, hidden=True)
-@click.option("--no-skip", is_flag=True, hidden=True)
-@click.option("--draft", is_flag=True, hidden=True)
+# These options are forwarded to the submit command when no subcommand is given.
+@click.option(
+    "--message",
+    "-m",
+    default="Update",
+    help="Description of change you made",
+)
+@click.option(
+    "--update-fields",
+    "-u",
+    is_flag=True,
+    help="Update GitHub pull request summary from the local commit",
+)
+@click.option(
+    "--short", is_flag=True, help="Print only the URL of the latest opened PR to stdout"
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="force push the branch even if your local branch is stale",
+)
+@click.option(
+    "--no-skip",
+    is_flag=True,
+    help="Never skip pushing commits, even if the contents didn't change",
+)
+@click.option(
+    "--draft",
+    is_flag=True,
+    help="Create the pull request in draft mode (only if it has not already been created)",
+)
 @click.option(
-    "--direct/--no-direct", "direct_opt", is_flag=True, hidden=True, default=None
+    "--direct/--no-direct",
+    "direct_opt",
+    is_flag=True,
+    default=None,
+    help="Create stack that directly merges into master",
+)
+@click.option(
+    "--base",
+    "-B",
+    default=None,
+    help="Branch to base the stack off of",
+)
+@click.option(
+    "--stack/--no-stack",
+    "-s/-S",
+    is_flag=True,
+    default=True,
+    help="Submit the entire stack of commits reachable from HEAD",
+)
+@click.option(
+    "--reviewer",
+    default=None,
+    help="Comma-separated list of GitHub usernames to add as reviewers",
+)
+@click.option(
+    "--label",
+    default=None,
+    help="Comma-separated list of labels to add to new PRs",
 )
-@click.option("--base", "-B", default=None, hidden=True)
-@click.option("--stack/--no-stack", "-s/-S", is_flag=True, default=True, hidden=True)
 def main(
     ctx: click.Context,
     debug: bool,
@@ -76,6 +129,8 @@ def main(
     draft: bool,
     base: Optional[str],
     stack: bool,
+    reviewer: Optional[str],
+    label: Optional[str],
 ) -> None:
     """
     Submit stacks of diffs to Github
@@ -100,9 +155,20 @@ def main(
             base=base,
             stack=stack,
             direct_opt=direct_opt,
+            reviewer=reviewer,
+            label=label,
         )
 
 
+@main.command("auth")
+def auth() -> None:
+    """
+    Set up GitHub authentication if not already configured.
+    """
+    with EXIT_STACK:
+        ghstack.config.read_config()
+
+
 @main.command("action")
 @click.option("--close", is_flag=True, help="Close the specified pull request")
 @click.argument("pull_request", metavar="PR")
@@ -147,8 +213,13 @@ def checkout(same_base: bool, pull_request: str) -> None:
     is_flag=True,
     help="Cherry-pick all commits from the commit to the merge-base with main branch",
 )
+@click.option(
+    "--no-fetch",
+    is_flag=True,
+    help="Skip fetching from the remote before cherry-picking",
+)
 @click.argument("pull_request", metavar="PR")
-def cherry_pick(stack: bool, pull_request: str) -> None:
+def cherry_pick(stack: bool, no_fetch: bool, pull_request: str) -> None:
     """
     Cherry-pick a PR
     """
@@ -159,6 +230,7 @@ def cherry_pick(stack: bool, pull_request: str) -> None:
             sh=shell,
             remote_name=config.remote_name,
             stack=stack,
+            no_fetch=no_fetch,
         )
 
 
@@ -180,6 +252,35 @@ def land(force: bool, pull_request: str) -> None:
         )
 
 
+@main.command(
+    "log",
+    context_settings={"ignore_unknown_options": True, "allow_extra_args": True},
+)
+@click.option(
+    "--pr",
+    "pull_request",
+    default=None,
+    help="Explicit PR (URL or number) to log.  If omitted, the PR is inferred "
+    "from HEAD's Pull-Request trailer, and local pending changes are shown "
+    "on top as a synthesized commit.",
+)
+@click.argument("git_log_args", nargs=-1, type=click.UNPROCESSED)
+def log(pull_request: Optional[str], git_log_args: Tuple[str, ...]) -> None:
+    """
+    Show git log for a PR, restricted to that PR's commits.
+    Extra arguments are forwarded to git log (e.g. -p).
+    """
+    with cli_context(request_github_token=False) as (shell, config, github):
+        ghstack.log.main(
+            github=github,
+            sh=shell,
+            remote_name=config.remote_name,
+            github_url=config.github_url,
+            args=list(git_log_args),
+            pull_request=pull_request,
+        )
+
+
 @main.command("rage")
 @click.option(
     "--latest",

{ghstack-0.14.0 → ghstack-0.15.0}/src/ghstack/github_fake.py

@@ -463,6 +463,24 @@ class FakeGitHubEndpoint(ghstack.github.GitHubEndpoint):
             if m:
                 # For now, pretend all branches are not protected
                 raise ghstack.github.NotFoundError()
+            if m := re.match(r"^repos/([^/]+)/([^/]+)/pulls/([^/]+)$", path):
+                state = self.state
+                repo = state.repository(m.group(1), m.group(2))
+                pr = state.pull_request(repo, GitHubNumber(int(m.group(3))))
+                return {
+                    "number": pr.number,
+                    "state": "closed" if pr.closed else "open",
+                    "title": pr.title,
+                    "body": pr.body,
+                }
+            if m := re.match(r"^repos/([^/]+)/([^/]+)/issues/comments/([^/]+)$", path):
+                state = self.state
+                repo = state.repository(m.group(1), m.group(2))
+                comment = state.issue_comment(repo, int(m.group(3)))
+                return {
+                    "id": comment.fullDatabaseId,
+                    "body": comment.body,
+                }
 
         elif method == "post":
             if m := re.match(r"^repos/([^/]+)/([^/]+)/pulls$", path):

{ghstack-0.14.0 → ghstack-0.15.0}/src/ghstack/land.py

@@ -145,13 +145,41 @@ to complain to the ghstack authors."""
             stack_orig_refs.append((ref, pr_resolved))
 
         # OK, actually do the land now
-        for orig_ref, _ in stack_orig_refs:
+        for orig_ref, pr_resolved in stack_orig_refs:
             try:
                 sh.git("cherry-pick", f"{remote_name}/{orig_ref}")
             except BaseException:
                 sh.git("cherry-pick", "--abort")
                 raise
 
+            # Add PR number to commit message like GitHub does
+            commit_msg = sh.git("log", "-1", "--pretty=%B")
+            # Get the original author and committer dates to preserve the commit hash
+            author_date = sh.git("log", "-1", "--pretty=%aD")
+            committer_date = sh.git("log", "-1", "--pretty=%cD")
+            lines = commit_msg.split("\n")
+            if lines:
+                # Add PR number to the subject line (first line)
+                subject = lines[0].rstrip()
+                # Only add if not already present
+                pr_tag = f"(#{pr_resolved.number})"
+                if pr_tag not in subject:
+                    subject = f"{subject} {pr_tag}"
+                lines[0] = subject
+                new_msg = "\n".join(lines)
+                # Preserve dates to keep the commit hash consistent
+                sh.git(
+                    "commit",
+                    "--amend",
+                    "-F",
+                    "-",
+                    input=new_msg,
+                    env={
+                        "GIT_AUTHOR_DATE": author_date,
+                        "GIT_COMMITTER_DATE": committer_date,
+                    },
+                )
+
         # All good! Push!
         maybe_force_arg = []
         if needs_force:

ghstack-0.15.0/src/ghstack/log.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+
+import subprocess
+import sys
+from typing import List, Optional, Tuple
+
+import ghstack.diff
+import ghstack.github
+import ghstack.github_utils
+import ghstack.shell
+
+
+def _resolve_refs(
+    *,
+    github: ghstack.github.GitHubEndpoint,
+    params: ghstack.github_utils.GitHubPullRequestParams,
+) -> Tuple[str, str]:
+    pr_result = github.graphql(
+        """
+        query ($owner: String!, $name: String!, $number: Int!) {
+            repository(name: $name, owner: $owner) {
+                pullRequest(number: $number) {
+                    headRefName
+                    baseRefName
+                }
+            }
+        }
+    """,
+        **params,
+    )
+    pr = pr_result["data"]["repository"]["pullRequest"]
+    return pr["headRefName"], pr["baseRefName"]
+
+
+def main(
+    github: ghstack.github.GitHubEndpoint,
+    sh: ghstack.shell.Shell,
+    remote_name: str,
+    github_url: str,
+    args: List[str],
+    pull_request: Optional[str] = None,
+) -> None:
+    if pull_request is not None:
+        # Explicit PR: fetch from remote and show what's there.  HEAD isn't
+        # involved; no synthesized pending-changes commit.
+        params = ghstack.github_utils.parse_pull_request(
+            pull_request, sh=sh, remote_name=remote_name
+        )
+        sh.git("fetch", "--prune", remote_name)
+        show_pending = False
+    else:
+        # Infer PR from HEAD's Pull-Request trailer; show the log relative
+        # to the local understanding of the remote state (no fetch).
+        commit_msg = sh.git("log", "-1", "--format=%B", "HEAD")
+        pr = ghstack.diff.PullRequestResolved.search(commit_msg, github_url)
+        if pr is None:
+            raise RuntimeError(
+                "HEAD commit is not associated with a ghstack pull request "
+                "(no Pull-Request trailer found). Check out the commit for the "
+                "PR you want to log, or pass the PR explicitly."
+            )
+        params = {
+            "github_url": pr.github_url,
+            "owner": pr.owner,
+            "name": pr.repo,
+            "number": pr.number,
+        }
+        show_pending = True
+
+    head_ref, base_ref = _resolve_refs(github=github, params=params)
+
+    remote_head = f"{remote_name}/{head_ref}"
+    remote_base = f"{remote_name}/{base_ref}"
+
+    tip = remote_head
+    if show_pending:
+        # If the local HEAD tree differs from the remote head tree, synthesize
+        # a disposable commit on top of the remote head so pending changes
+        # show up as the newest commit in `git log`.
+        local_tree = sh.git("rev-parse", "HEAD^{tree}")
+        remote_tree = sh.git("rev-parse", f"{remote_head}^{{tree}}")
+        if local_tree != remote_tree:
+            tip = sh.git(
+                "commit-tree",
+                local_tree,
+                "-p",
+                remote_head,
+                input="Local pending changes (not yet submitted)\n",
+            )
+
+    # ^remote_base restricts the walk to the head chain (each head commit is a
+    # merge of the previous head and a base-update commit; excluding everything
+    # reachable from the base ref drops the base-update side).
+    #
+    # --diff-merges=remerge replays the merge and diffs the stored tree
+    # against the auto-merge result, which for ghstack isolates just the
+    # user's code edits from the base-update changes that got folded in.
+    # This only affects merge commits (non-merges still need -p).  Requires
+    # git 2.35+.  Users who prefer a portable alternative can pass
+    # --diff-merges=cc to override.
+    log_args = ["--diff-merges=remerge", tip]
+    if sh.git("rev-parse", "--verify", "--quiet", remote_base, exitcode=True):
+        log_args.append(f"^{remote_base}")
+    log_args.extend(args)
+
+    if sys.stdout.isatty():
+        # Let git manage its own pager.
+        subprocess.run(["git", "log", *log_args], cwd=sh.cwd, check=False)
+    else:
+        # In test/piped contexts, capture and write to sys.stdout so the
+        # caller can intercept it.
+        out = sh.git("log", *log_args)
+        if out:
+            sys.stdout.write(out)
+            if not out.endswith("\n"):
+                sys.stdout.write("\n")

{ghstack-0.14.0 → ghstack-0.15.0}/src/ghstack/submit.py

@@ -90,6 +90,7 @@ class PreBranchState:
 
 # Ya, sometimes we get carriage returns.  Crazy right?
 RE_STACK = re.compile(r"Stack.*:\r?\n(\* [^\r\n]+\r?\n)+")
+RE_STACK_PR_NUMBER = re.compile(r"#(\d+)")
 
 
 # NB: This regex is fuzzy because the D1234567 identifier is typically
@@ -487,18 +488,20 @@ class Submitter:
                 d = ghstack.git.convert_header(h, self.github_url)
                 if d.pull_request_resolved is not None:
                     ed = self.elaborate_diff(d)
-                    pre_branch_state_index[h.commit_id] = PreBranchState(
-                        head_commit_id=GitCommitHash(
-                            self.sh.git(
-                                "rev-parse", f"{self.remote_name}/{ed.head_ref}"
-                            )
-                        ),
-                        base_commit_id=GitCommitHash(
-                            self.sh.git(
-                                "rev-parse", f"{self.remote_name}/{ed.base_ref}"
-                            )
-                        ),
-                    )
+                    # Skip closed PRs (e.g., after landing) where branches have been deleted
+                    if not ed.closed:
+                        pre_branch_state_index[h.commit_id] = PreBranchState(
+                            head_commit_id=GitCommitHash(
+                                self.sh.git(
+                                    "rev-parse", f"{self.remote_name}/{ed.head_ref}"
+                                )
+                            ),
+                            base_commit_id=GitCommitHash(
+                                self.sh.git(
+                                    "rev-parse", f"{self.remote_name}/{ed.base_ref}"
+                                )
+                            ),
+                        )
 
         # NB: deduplicates
         commit_index = {
@@ -516,7 +519,12 @@ class Submitter:
             for h in commits_to_submit
             if h.commit_id in diff_meta_index
         ]
-        self.push_updates(diffs_to_submit)
+        all_diffs_in_topo_order = [
+            diff_meta_index[h.commit_id]
+            for h in commits_to_rebase
+            if h.commit_id in diff_meta_index
+        ]
+        self.push_updates(diffs_to_submit, all_diffs=all_diffs_in_topo_order)
         if new_head := rebase_index.get(
             old_head := GitCommitHash(self.sh.git("rev-parse", "HEAD"))
         ):
@@ -870,21 +878,24 @@ to disassociate the commit with the pull request, and then try again.
                 "--header",
                 self.remote_name + "/" + branch_orig(username, gh_number),
             )
-        except RuntimeError as e:
+        except RuntimeError:
             if r["closed"]:
-                raise RuntimeError(
-                    f"Cannot ghstack a stack with closed PR #{number} whose branch was deleted.  "
-                    "If you were just trying to update a later PR in the stack, `git rebase` and try again.  "
-                    "Otherwise, you may have been trying to update a PR that was already closed. "
-                    "To disassociate your update from the old PR and open a new PR, "
-                    "run `ghstack unlink`, `git rebase` and then try again."
-                ) from e
-            raise
-        remote_summary = ghstack.git.split_header(rev_list)[0]
-        m_remote_source_id = RE_GHSTACK_SOURCE_ID.search(remote_summary.commit_msg)
-        remote_source_id = m_remote_source_id.group(1) if m_remote_source_id else None
-        m_comment_id = RE_GHSTACK_COMMENT_ID.search(remote_summary.commit_msg)
-        comment_id = int(m_comment_id.group(1)) if m_comment_id else None
+                # If the PR is closed and the branch is deleted (e.g., after landing),
+                # we can't get the remote source ID. Return None for it, which will
+                # signal to process_commit that this commit has been landed and should
+                # be skipped (not updated).
+                remote_source_id = None
+                comment_id = None
+            else:
+                raise
+        else:
+            remote_summary = ghstack.git.split_header(rev_list)[0]
+            m_remote_source_id = RE_GHSTACK_SOURCE_ID.search(remote_summary.commit_msg)
+            remote_source_id = (
+                m_remote_source_id.group(1) if m_remote_source_id else None
+            )
+            m_comment_id = RE_GHSTACK_COMMENT_ID.search(remote_summary.commit_msg)
+            comment_id = int(m_comment_id.group(1)) if m_comment_id else None
 
         return DiffWithGitHubMetadata(
             diff=diff,
@@ -917,6 +928,48 @@ to disassociate the commit with the pull request, and then try again.
         if elab_diff is not None and elab_diff.closed:
             if self.direct:
                 self._raise_needs_rebase()
+            # If we're trying to submit a closed commit, check if it has been modified
+            if elab_diff.remote_source_id is None:
+                # The branch was deleted (e.g., after landing). Check if the commit has been
+                # modified by comparing source_ids. If the commit is reachable from master with
+                # the same source_id (tree hash), it means it was landed and we should skip it.
+                # Otherwise, it's been modified and we should raise an error.
+                try:
+                    # Check if there's a commit on master with the same tree (source_id)
+                    master_commits = self.sh.git(
+                        "log",
+                        "--format=%H %T",
+                        f"{self.remote_name}/{self.base}",
+                        "-n",
+                        "100",  # Check last 100 commits
+                    )
+                    for line in master_commits.split("\n"):
+                        if not line.strip():
+                            continue
+                        commit_hash, tree_hash = line.split()
+                        if tree_hash == diff.source_id:
+                            # Found a commit on master with the same tree, so this commit
+                            # was landed (just with a different commit message/hash)
+                            return None
+                except Exception:
+                    pass
+                # Didn't find a matching commit on master, so this is a modified closed commit
+                raise RuntimeError(
+                    f"Cannot ghstack a stack with closed PR #{elab_diff.number} whose branch was deleted.  "
+                    "If you were just trying to update a later PR in the stack, `git rebase` and try again.  "
+                    "Otherwise, you may have been trying to update a PR that was already closed. "
+                    "To disassociate your update from the old PR and open a new PR, "
+                    "run `ghstack unlink`, `git rebase` and then try again."
+                )
+            elif diff.source_id != elab_diff.remote_source_id:
+                # The commit has been modified locally
+                raise RuntimeError(
+                    f"Cannot ghstack a stack with closed PR #{elab_diff.number} whose branch was deleted.  "
+                    "If you were just trying to update a later PR in the stack, `git rebase` and try again.  "
+                    "Otherwise, you may have been trying to update a PR that was already closed. "
+                    "To disassociate your update from the old PR and open a new PR, "
+                    "run `ghstack unlink`, `git rebase` and then try again."
+                )
             return None
 
         # Edge case: check if the commit is empty; if so skip submitting
@@ -1491,7 +1544,11 @@ is closed (likely due to being merged).  Please rebase to upstream and try again
         )
 
     def push_updates(
-        self, diffs_to_submit: List[DiffMeta], *, import_help: bool = True
+        self,
+        diffs_to_submit: List[DiffMeta],
+        *,
+        all_diffs: Optional[List[DiffMeta]] = None,
+        import_help: bool = True,
     ) -> None:
         # update pull request information, update bases as necessary
         #   preferably do this in one network call
@@ -1524,6 +1581,46 @@ is closed (likely due to being merged).  Please rebase to upstream and try again
         if force_push_branches:
             self._git_push(force_push_branches, force=True)
 
+        # Discover orphan PR numbers from the old stack listing.
+        # We search the full local stack for old stack text, then
+        # collect open PRs that aren't being submitted — both above
+        # and below the submitted ones.  Closed PRs are filtered out.
+        submitted_numbers = {s.number for s in diffs_to_submit}
+        orphan_above: List[GitHubNumber] = []
+        orphan_below: List[GitHubNumber] = []
+        for s in all_diffs or diffs_to_submit:
+            old_stack_text: Optional[str] = None
+            if self.direct and s.elab_diff.comment_id is not None:
+                r = self.github.get(
+                    f"repos/{self.repo_owner}/{self.repo_name}/issues/comments/{s.elab_diff.comment_id}",
+                )
+                old_stack_text = r.get("body")
+            else:
+                m = RE_STACK.search(s.body)
+                if m:
+                    old_stack_text = m.group(0)
+            if old_stack_text:
+                old_pr_numbers = [
+                    GitHubNumber(int(n))
+                    for n in RE_STACK_PR_NUMBER.findall(old_stack_text)
+                ]
+                if not old_pr_numbers:
+                    continue
+                seen_submitted = False
+                for num in old_pr_numbers:
+                    if num in submitted_numbers:
+                        seen_submitted = True
+                        continue
+                    pr_info = self.github.get(
+                        f"repos/{self.repo_owner}/{self.repo_name}/pulls/{num}",
+                    )
+                    if pr_info.get("state") == "open":
+                        if seen_submitted:
+                            orphan_below.append(num)
+                        else:
+                            orphan_above.append(num)
+                break
+
         for s in reversed(diffs_to_submit):
             # NB: GraphQL API does not support modifying PRs
             assert not s.closed
@@ -1541,7 +1638,9 @@ is closed (likely due to being merged).  Please rebase to upstream and try again
                 base_kwargs["base"] = s.base
             else:
                 assert s.base == s.elab_diff.base_ref
-            stack_desc = self._format_stack(diffs_to_submit, s.number)
+            stack_desc = self._format_stack(
+                diffs_to_submit, s.number, orphan_above, orphan_below
+            )
             self.github.patch(
                 "repos/{owner}/{repo}/pulls/{number}".format(
                     owner=self.repo_owner, repo=self.repo_name, number=s.number
@@ -1761,14 +1860,24 @@ is closed (likely due to being merged).  Please rebase to upstream and try again
     # - want "as complete" a tree as possible; this may involve
     #   poking around the xrefs to find out all the other PRs
     #   involved in the stack
-    def _format_stack(self, diffs_to_submit: List[DiffMeta], number: int) -> str:
+    def _format_stack(
+        self,
+        diffs_to_submit: List[DiffMeta],
+        number: int,
+        orphan_above: Sequence[GitHubNumber] = (),
+        orphan_below: Sequence[GitHubNumber] = (),
+    ) -> str:
         rows = []
+        for n in orphan_above:
+            rows.append(f"* #{n}")
         # NB: top is top of stack, opposite of update order
         for s in diffs_to_submit:
             if s.number == number:
                 rows.append(f"* __->__ #{s.number}")
             else:
                 rows.append(f"* #{s.number}")
+        for n in orphan_below:
+            rows.append(f"* #{n}")
         return self.stack_header + ":\n" + "\n".join(rows) + "\n"
 
     def _default_title_and_body(

{ghstack-0.14.0 → ghstack-0.15.0}/src/ghstack/test_prelude.py

@@ -8,7 +8,7 @@ import shutil
 import stat
 import sys
 import tempfile
-from typing import Any, Callable, Iterator, List, Optional, Sequence, Tuple, Union
+from typing import Any, Callable, Iterator, List, Optional, Sequence, Tuple, Type, Union
 
 from expecttest import assert_expected_inline
 
@@ -19,6 +19,7 @@ import ghstack.github
 import ghstack.github_fake
 import ghstack.github_utils
 import ghstack.land
+import ghstack.log
 import ghstack.shell
 import ghstack.submit
 import ghstack.unlink
@@ -34,6 +35,7 @@ __all__ = [
     "gh_unlink",
     "gh_cherry_pick",
     "gh_checkout",
+    "gh_log",
     "GitCommitHash",
     "checkout",
     "amend",
@@ -270,6 +272,18 @@ def gh_checkout(pull_request: str, same_base: bool = False) -> None:
     )
 
 
+def gh_log(pull_request: Optional[str] = None, args: Sequence[str] = ()) -> None:
+    self = CTX
+    return ghstack.log.main(
+        github=self.github,
+        sh=self.sh,
+        remote_name="origin",
+        github_url="github.com",
+        args=list(args),
+        pull_request=pull_request,
+    )
+
+
 def write_file_and_add(filename: str, contents: str) -> None:
     self = CTX
     with self.sh.open(filename, "w") as f:
@@ -392,8 +406,10 @@ def is_direct() -> bool:
     return CTX.direct
 
 
-def get_github() -> ghstack.github_fake.FakeGitHubEndpoint:
-    return CTX.github
+def get_github() -> "ghstack.github_fake.FakeGitHubEndpoint":
+    github = CTX.github
+    assert isinstance(github, ghstack.github_fake.FakeGitHubEndpoint)
+    return github
 
 
 def get_pr_reviewers(pr_number: int) -> List[str]:
@@ -417,8 +433,11 @@ def assert_eq(a: Any, b: Any) -> None:
 
 
 def assert_raises(
-    exc_type: any, callable: Callable[..., any], *args: any, **kwargs: any
-):
+    exc_type: Type[BaseException],
+    callable: Callable[..., Any],
+    *args: Any,
+    **kwargs: Any,
+) -> None:
     try:
         callable(*args, **kwargs)
     except exc_type:
@@ -427,8 +446,12 @@ def assert_raises(
 
 
 def assert_expected_raises_inline(
-    exc_type: any, callable: Callable[..., any], expect: str, *args: any, **kwargs: any
-):
+    exc_type: Type[BaseException],
+    callable: Callable[..., Any],
+    expect: str,
+    *args: Any,
+    **kwargs: Any,
+) -> None:
     try:
         callable(*args, **kwargs)
     except exc_type as e: