lazy-github 0.3.0__tar.gz → 0.3.2__tar.gz

lazy_github-0.3.2/.github/workflows/publish.yaml

@@ -0,0 +1,61 @@
+name: Publish the package to pypi
+
+on: workflow_dispatch
+
+jobs:
+  pypi-publish:
+    name: Upload release to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/lazy-github
+    permissions:
+      id-token: write
+    outputs:
+      new-version: ${{ steps.calculate-version.outputs.version }}
+    steps:
+      # Perform a bunch of setup
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
+    - uses: yezz123/setup-uv@v4
+
+    - name: Calculate version
+      id: calculate-version
+      run: |
+        new_version=$(uvx hatch version)
+        echo "version=${new_version}" >> $GITHUB_OUTPUT
+
+      # Build the distribution
+    - name: Build lazy-github distribution
+      run: uvx hatch build
+
+    - name: Publish package distributions to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+
+  create-tag:
+    name: Create tag
+    needs: pypi-publish
+    permissions: write-all
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/github-script@v7
+      with:
+        script: |
+          github.rest.git.createRef({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              ref: 'refs/tags/v${{ needs.pypi-publish.outputs.new-version }}',
+              sha: context.sha
+            })
+
+  notify-discord:
+    name: Notify when this workflow completes (regardless of success or failure)
+    needs: pypi-publish
+    runs-on: ubuntu-latest
+    steps:
+    - uses: nobrayner/discord-webhook@v1
+      with:
+        title: "Version ${{ needs.pypi-publish.outputs.new-version }} published to PyPi"
+        description: "Check out the new version [here](https://pypi.org/project/lazy-github/${{ needs.pypi-publish.outputs.new-version }}/)"
+        github-token: ${{ secrets.github_token }}
+        discord-webhook: ${{ secrets.DISCORD_WEBHOOK }}

{lazy_github-0.3.0 → lazy_github-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazy-github
-Version: 0.3.0
+Version: 0.3.2
 Summary: A terminal UI for interacting with Github
 Author-email: "Chris (Gizmo)" <gizmo385@users.noreply.github.com>
 Maintainer-email: "Chris (Gizmo)" <gizmo385@users.noreply.github.com>

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/lib/bindings.py

@@ -8,18 +8,19 @@ class LazyGithubBindings:
     # Global App Bindings
     QUIT_APP = Binding("q", "quit", "Quit", id="app.quit")
     OPEN_COMMAND_PALLETE = Binding("ctrl+p", "command_palette", "Commands", id="app.command_palette")
-    MAXIMIZE_WIDGET = Binding("ctrl+m", "maximize", "Maximize", id="app.maximize_widget")
+    MAXIMIZE_WIDGET = Binding("M", "maximize", "Maximize", id="app.maximize_widget")
 
     # Triggering creation flows
     OPEN_ISSUE = Binding("I", "open_issue", "New Issue", id="issue.new")
     EDIT_ISSUE = Binding("E", "edit_issue", "Edit Issue", id="issue.edit")
-    OPEN_PULL_REQUEST = Binding("P", "open_pull_request", "New PR", id="pull_request.new")
     NEW_COMMENT = Binding("n", "new_comment", "New Comment", id="conversation.comment.new")
     REPLY_TO_REVIEW = Binding("r", "reply_to_review", "Reply to Review", id="conversation.review.reply")
     REPLY_TO_COMMENT = Binding("r", "reply_to_individual_comment", "Reply to Comment", id="conversation.comment.reply")
 
     # Pull request actions
-    MERGE_PULL_REQUEST = Binding("M", "merge_pull_request", "Merge PR", id="pull_request.merge")
+    OPEN_PULL_REQUEST = Binding("P", "open_pull_request", "New PR", id="pull_request.new")
+    MERGE_PULL_REQUEST = Binding("ctrl+m", "merge_pull_request", "Merge PR", id="pull_request.merge")
+    LOOKUP_PULL_REQUEST = Binding("O", "lookup_pull_request", "Lookup Pull Request", id="pull_request.lookup")
 
     # Repository actions
     TOGGLE_FAVORITE_REPO = Binding("ctrl+f", "toggle_favorite_repo", "Toggle Favorite", id="repositories.favorite")

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/lib/config.py

@@ -1,6 +1,7 @@
 import json
 from contextlib import contextmanager
 from datetime import timedelta
+from enum import StrEnum
 from pathlib import Path
 from typing import Any, Generator, Literal, Optional
 
@@ -71,11 +72,18 @@ class RepositorySettings(BaseModel):
     favorites: list[str] = []
 
 
+class MergeMethod(StrEnum):
+    MERGE = "merge"
+    SQUASH = "squash"
+    REBASE = "rebase"
+
+
 class PullRequestSettings(BaseModel):
     """Changes how pull requests are retrieved from the Github API"""
 
     state_filter: IssueStateFilter = IssueStateFilter.ALL
     owner_filter: IssueOwnerFilter = IssueOwnerFilter.ALL
+    preferred_merge_method: MergeMethod = MergeMethod.SQUASH
 
 
 class IssueSettings(BaseModel):

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/lib/constants.py

@@ -12,7 +12,7 @@ DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code"
 # Symbols used in various UI tables
 IS_FAVORITED = "[green]★[/green]"
 IS_NOT_FAVORITED = "☆"
-CHECKMARK = "✔"
+CHECKMARK = "✓"
 X_MARK = "✘"
 BULLET_POINT = "•"
 

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/lib/context.py

@@ -1,10 +1,12 @@
+import logging
 from typing import Optional
 
 from lazy_github.lib.config import Config
 from lazy_github.lib.constants import JSON_CONTENT_ACCEPT_TYPE
-from lazy_github.lib.git_cli import current_local_repo_full_name
+from lazy_github.lib.git_cli import current_local_branch_name, current_local_repo_full_name
 from lazy_github.lib.github.backends.protocol import BackendType
 from lazy_github.lib.github.client import GithubClient
+from lazy_github.lib.logging import LazyGithubLogFormatter, lg
 from lazy_github.lib.utils import classproperty
 from lazy_github.models.github import Repository
 
@@ -16,14 +18,27 @@ class LazyGithubContext:
     _config: Config | None = None
     _client: GithubClient | None = None
     _current_directory_repo: str | None = None
+    _current_directory_branch: str | None = None
 
     # Directly assigned attributes
     current_repo: Repository | None = None
 
+    @classmethod
+    def _setup_logging_handler(cls, config: Config) -> None:
+        """Setup the file logger for LazyGithub"""
+        try:
+            config.core.logfile_path.parent.mkdir(parents=True, exist_ok=True)
+            lg_file_handler = logging.FileHandler(filename=config.core.logfile_path)
+            lg_file_handler.setFormatter(LazyGithubLogFormatter())
+            lg.addHandler(lg_file_handler)
+        except Exception:
+            lg.exception("Failed to setup file logger for LazyGithub")
+
     @classproperty
     def config(cls) -> Config:
         if cls._config is None:
             cls._config = Config.load_config()
+            cls._setup_logging_handler(cls._config)
         return cls._config
 
     @classproperty
@@ -52,6 +67,13 @@ class LazyGithubContext:
             cls._current_directory_repo = current_local_repo_full_name()
         return cls._current_directory_repo
 
+    @classproperty
+    def current_directory_branch(cls) -> str | None:
+        """The owner/name of the repo associated with the current working directory (if one exists)"""
+        if not cls._current_directory_branch:
+            cls._current_directory_branch = current_local_branch_name()
+        return cls._current_directory_branch
+
 
 def github_headers(accept: str = JSON_CONTENT_ACCEPT_TYPE, cache_duration: Optional[int] = None) -> dict[str, str]:
     """Helper function to build headers for Github API requests"""

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/lib/github/backends/cli.py

@@ -9,6 +9,7 @@ from typing import Any
 from lazy_github.lib.config import Config
 from lazy_github.lib.constants import CONFIG_FOLDER, JSON_CONTENT_ACCEPT_TYPE
 from lazy_github.lib.github.backends.protocol import GithubApiBackend, GithubApiRequestFailed, GithubApiResponse
+from lazy_github.lib.logging import lg
 from lazy_github.models.github import User
 
 _HEADER_RE = re.compile(r"^([a-zA-Z-]+)\:(.+)$")
@@ -66,7 +67,6 @@ def _clear_temporary_bodies() -> None:
 
 async def run_gh_cli_command(command: list[str]) -> CliApiResponse:
     """Simple wrapper around running a Github CLI command"""
-    from lazy_github.lib.logging import lg
 
     proc = await asyncio.create_subprocess_exec(
         "gh", *command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
@@ -158,6 +158,15 @@ class GithubCliBackend(GithubApiBackend):
         command = _build_command(url, headers=headers, body=json, method="PATCH")
         return await run_gh_cli_command(command)
 
+    async def put(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        json: dict[str, str] | None = None,
+    ) -> Any:
+        command = _build_command(url, headers=headers, body=json, method="PUT")
+        return await run_gh_cli_command(command)
+
     async def get_user(self) -> User:
         response = await self.get("/user")
         return User(**response.json())

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/lib/github/backends/hishel.py

@@ -69,6 +69,15 @@ class HishelGithubApiBackend(GithubApiBackend):
         response = await self.api_client.patch(url, headers=headers, json=json)
         return HishelApiResponse(response)
 
+    async def put(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        json: dict[str, str] | None = None,
+    ) -> HishelApiResponse:
+        response = await self.api_client.put(url, headers=headers, json=json)
+        return HishelApiResponse(response)
+
     def github_headers(
         self, accept: str = JSON_CONTENT_ACCEPT_TYPE, cache_duration: int | None = None
     ) -> dict[str, str]:

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/lib/github/backends/protocol.py

@@ -48,6 +48,13 @@ class GithubApiBackend(Protocol):
         json: dict[str, str] | None = None,
     ) -> GithubApiResponse: ...
 
+    async def put(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        json: dict[str, str] | None = None,
+    ) -> GithubApiResponse: ...
+
     async def get_user(self) -> User: ...
 
     def github_headers(

lazy_github-0.3.2/lazy_github/lib/github/checks.py

@@ -0,0 +1,13 @@
+from lazy_github.lib.context import LazyGithubContext, github_headers
+from lazy_github.models.github import CombinedCheckStatus, Repository
+
+
+async def combined_check_status_for_ref(
+    repo: Repository, ref: str, per_page: int = 100, page: int = 1
+) -> CombinedCheckStatus:
+    query_params = {"page": page, "per_page": per_page}
+    response = await LazyGithubContext.client.get(
+        f"/repos/{repo.owner.login}/{repo.name}/commits/{ref}/status", headers=github_headers(), params=query_params
+    )
+    response.raise_for_status()
+    return CombinedCheckStatus(**response.json())

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/lib/github/client.py

@@ -45,5 +45,8 @@ class GithubClient(GithubApiBackend):
     async def patch(self, url: str, headers: dict[str, str] | None = None, json: dict[str, str] | None = None) -> Any:
         return await self.backend.patch(url, headers, json)
 
+    async def put(self, url: str, headers: dict[str, str] | None = None, json: dict[str, str] | None = None) -> Any:
+        return await self.backend.put(url, headers, json)
+
     async def get_user(self) -> User:
         return await self.backend.get_user()

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/lib/github/pull_requests.py

@@ -1,3 +1,4 @@
+from lazy_github.lib.config import MergeMethod
 from lazy_github.lib.constants import DIFF_CONTENT_ACCEPT_TYPE
 from lazy_github.lib.context import LazyGithubContext, github_headers
 from lazy_github.lib.github.backends.cli import run_gh_cli_command
@@ -7,6 +8,7 @@ from lazy_github.models.github import (
     FullPullRequest,
     Issue,
     PartialPullRequest,
+    PullRequestMergeResult,
     Repository,
     Review,
     ReviewComment,
@@ -24,13 +26,13 @@ async def list_for_repo(repo: Repository) -> list[PartialPullRequest]:
 async def create_pull_request(
     repo: Repository, title: str, body: str, base_ref: str, head_ref: str, draft: bool = False
 ) -> FullPullRequest:
-    user = await LazyGithubContext.client.user()
     url = f"/repos/{repo.owner.login}/{repo.name}/pulls"
     request_body = {
         "title": title,
         "draft": draft,
         "base": base_ref,
-        "head": f"{user.login}:{head_ref}",
+        # TODO: This prevents it from working with forks, but means it'll work for same-repo PRs. Issue
+        "head": f"{repo.owner.login}:{head_ref}",
     }
     if body:
         request_body["body"] = body
@@ -39,12 +41,12 @@ async def create_pull_request(
     return FullPullRequest(**response.json(), repo=repo)
 
 
-async def get_full_pull_request(partial_pr: PartialPullRequest) -> FullPullRequest:
+async def get_full_pull_request(repo: Repository, pr_number: int) -> FullPullRequest:
     """Converts a partial pull request into a full pull request"""
-    url = f"/repos/{partial_pr.repo.owner.login}/{partial_pr.repo.name}/pulls/{partial_pr.number}"
+    url = f"/repos/{repo.owner.login}/{repo.name}/pulls/{pr_number}"
     response = await LazyGithubContext.client.get(url, headers=github_headers())
     response.raise_for_status()
-    return FullPullRequest(**response.json(), repo=partial_pr.repo)
+    return FullPullRequest(**response.json(), repo=repo)
 
 
 async def get_diff(pr: FullPullRequest) -> str:
@@ -62,6 +64,17 @@ async def get_diff(pr: FullPullRequest) -> str:
     return response.text
 
 
+async def merge_pull_request(pr: FullPullRequest, merge_method: MergeMethod) -> PullRequestMergeResult:
+    """
+    Attempts to merge the PR via the Github API. The head sha of the PR must match for the merge to be successful.
+    """
+    url = f"/repos/{pr.repo.owner.login}/{pr.repo.name}/pulls/{pr.number}/merge"
+    body = {"merge_method": merge_method, "sha": pr.head.sha}
+    response = await LazyGithubContext.client.put(url, headers=github_headers(), json=body)
+    response.raise_for_status()
+    return PullRequestMergeResult(**response.json())
+
+
 async def get_review_comments(pr: FullPullRequest, review: Review) -> list[ReviewComment]:
     url = f"/repos/{pr.repo.owner.login}/{pr.repo.name}/pulls/{pr.number}/reviews/{review.id}/comments"
     response = await LazyGithubContext.client.get(url, headers=github_headers())

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/lib/logging.py

@@ -1,7 +1,5 @@
 import logging
 
-from lazy_github.lib.context import LazyGithubContext
-
 
 # A universal logging format that we can use
 class LazyGithubLogFormatter(logging.Formatter):
@@ -16,11 +14,7 @@ class LazyGithubLogFormatter(logging.Formatter):
         return super().format(record)
 
 
-LazyGithubContext.config.core.logfile_path.parent.mkdir(parents=True, exist_ok=True)
 lg = logging.Logger("lazy_github", level=logging.DEBUG)
-_lg_file_handler = logging.FileHandler(filename=LazyGithubContext.config.core.logfile_path)
-_lg_file_handler.setFormatter(LazyGithubLogFormatter())
-lg.addHandler(_lg_file_handler)
 
 
 # Override the logging level for a bunch of noisy library loggers

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/models/github.py

@@ -61,6 +61,7 @@ class Issue(BaseModel):
 class Ref(BaseModel):
     user: User
     ref: str
+    sha: str
 
 
 class PartialPullRequest(Issue):
@@ -84,6 +85,12 @@ class FullPullRequest(PartialPullRequest):
     diff_url: str
 
 
+class PullRequestMergeResult(BaseModel):
+    sha: str
+    merged: bool
+    message: str
+
+
 class AuthorAssociation(StrEnum):
     COLLABORATOR = "COLLABORATOR"
     CONTRIBUTOR = "CONTRIBUTOR"
@@ -189,3 +196,24 @@ class Notification(BaseModel):
     unread: bool
     updated_at: datetime
     last_read_at: datetime | None
+
+
+class CheckStatusState(StrEnum):
+    SUCCESS = "success"
+    PENDING = "pending"
+    ERROR = "error"
+    FAILURE = "failure"
+
+
+class CheckStatus(BaseModel):
+    description: str
+    context: str
+    state: CheckStatusState
+    target_url: str | None
+    updated_at: datetime | None
+    created_at: datetime | None
+
+
+class CombinedCheckStatus(BaseModel):
+    state: CheckStatusState
+    statuses: list[CheckStatus]

lazy_github-0.3.2/lazy_github/ui/screens/lookup_pull_request.py

@@ -0,0 +1,88 @@
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, Markdown, Rule
+
+from lazy_github.lib.bindings import LazyGithubBindings
+from lazy_github.lib.context import LazyGithubContext
+from lazy_github.lib.github.backends.protocol import GithubApiRequestFailed
+from lazy_github.lib.github.pull_requests import get_full_pull_request
+from lazy_github.models.github import FullPullRequest
+from lazy_github.ui.widgets.common import LazyGithubFooter
+
+
+class LookupPullRequestButtons(Horizontal):
+    DEFAULT_CSS = """
+    LookupPullRequestButtons {
+        align: center middle;
+        height: auto;
+        width: 100%;
+    }
+    Button {
+        margin: 1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Button("Open", id="lookup", variant="success")
+        yield Button("Cancel", id="cancel", variant="error")
+
+
+class LookupPullRequestContainer(Container):
+    DEFAULT_CSS = """
+    LookupPullRequestContainer {
+        align: center middle;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Markdown("# Search for a pull request by number:")
+        yield Label("[bold]Pull Request Number:[/bold]")
+        yield Input(
+            id="pull_request_number",
+            placeholder="Pull request number",
+            type="number",
+        )
+        yield Rule()
+        yield LookupPullRequestButtons()
+
+
+class LookupPullRequestModal(ModalScreen[FullPullRequest | None]):
+    DEFAULT_CSS = """
+    LookupPullRequestModal {
+        align: center middle;
+        content-align: center middle;
+    }
+
+    LookupPullRequestContainer {
+        width: 60;
+        max-height: 25;
+        border: thick $background 80%;
+        background: $surface-lighten-3;
+    }
+    """
+
+    BINDINGS = [LazyGithubBindings.SUBMIT_DIALOG, LazyGithubBindings.CLOSE_DIALOG]
+
+    def compose(self) -> ComposeResult:
+        yield LookupPullRequestContainer()
+        yield LazyGithubFooter()
+
+    @on(Button.Pressed, "#lookup")
+    async def action_submit(self) -> None:
+        assert LazyGithubContext.current_repo is not None, "Current repo is missing!"
+
+        try:
+            pr_number = int(self.query_one("#pull_request_number", Input).value)
+            pull_request = await get_full_pull_request(LazyGithubContext.current_repo, pr_number)
+        except ValueError:
+            self.notify("Must enter a valid pull request number!", title="Invalid PR Number", severity="error")
+        except GithubApiRequestFailed:
+            self.notify("Could not find pull request!", title="Unknown PR", severity="error")
+        else:
+            self.dismiss(pull_request)
+
+    @on(Button.Pressed, "#cancel")
+    async def action_close(self) -> None:
+        self.dismiss(None)

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/ui/screens/lookup_repository.py

@@ -54,11 +54,11 @@ class LookupRepositoryContainer(Container):
 class LookupRepositoryModal(ModalScreen[Repository | None]):
     DEFAULT_CSS = """
     LookupRepositoryModal {
-        height: 80%;
+        align: center middle;
+        content-align: center middle;
     }
 
     LookupRepositoryContainer {
-        dock: top;
         width: 60;
         max-height: 25;
         border: thick $background 80%;
@@ -78,7 +78,7 @@ class LookupRepositoryModal(ModalScreen[Repository | None]):
                 # If we haven't tracked this repo already, we will do so
                 config.repositories.additional_repos_to_track.append(repo_name)
 
-    @on(Button.Pressed, "#submit")
+    @on(Button.Pressed, "#lookup")
     async def action_submit(self) -> None:
         repo_input = self.query_one("#repo_to_lookup", Input)
         continue_tracking_input = self.query_one("#continue_tracking", Switch)

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/ui/screens/new_issue.py

@@ -22,6 +22,10 @@ class NewIssueContainer(Container):
         height: 80%;
     }
 
+    #new_issue_title {
+        height: auto;
+    }
+
     #new_issue_body {
         height: 15;
     }

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/ui/screens/new_pull_request.py

@@ -64,8 +64,18 @@ class BranchSelection(Horizontal):
     def base_ref(self) -> str:
         return self._base_ref_input.value
 
+    @work
+    async def set_default_branch_value(self) -> None:
+        if (
+            LazyGithubContext.current_directory_repo
+            and LazyGithubContext.current_repo
+            and LazyGithubContext.current_directory_repo == LazyGithubContext.current_repo.full_name
+        ):
+            self.query_one("#head_ref", Input).value = LazyGithubContext.current_directory_branch
+
     async def on_mount(self) -> None:
         self.fetch_branches()
+        self.set_default_branch_value()
 
     @on(BranchesLoaded)
     def handle_loaded_branches(self, message: BranchesLoaded) -> None:

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/ui/screens/primary.py

@@ -270,7 +270,7 @@ class MainViewPane(Container):
         return self.query_one("#selection_details", SelectionDetailsContainer)
 
     async def on_pull_request_selected(self, message: PullRequestSelected) -> None:
-        full_pr = await get_full_pull_request(message.pr)
+        full_pr = await get_full_pull_request(message.pr.repo, message.pr.number)
         tabbed_content = self.query_one("#selection_detail_tabs", TabbedContent)
         await tabbed_content.clear_panes()
         await tabbed_content.add_pane(PrOverviewTabPane(full_pr))

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/ui/widgets/pull_requests.py

@@ -3,20 +3,30 @@ from textual import on, work
 from textual.app import ComposeResult
 from textual.containers import ScrollableContainer, VerticalScroll
 from textual.coordinate import Coordinate
-from textual.widgets import DataTable, Label, Markdown, RichLog, Rule, TabPane
+from textual.widgets import Collapsible, DataTable, Label, ListItem, ListView, Markdown, RichLog, Rule, TabPane
 
 from lazy_github.lib.bindings import LazyGithubBindings
+from lazy_github.lib.constants import CHECKMARK, X_MARK
 from lazy_github.lib.context import LazyGithubContext
+from lazy_github.lib.github.backends.protocol import GithubApiRequestFailed
+from lazy_github.lib.github.checks import combined_check_status_for_ref
 from lazy_github.lib.github.issues import get_comments, list_issues
 from lazy_github.lib.github.pull_requests import (
     get_diff,
     get_reviews,
+    merge_pull_request,
     reconstruct_review_conversation_hierarchy,
 )
 from lazy_github.lib.logging import lg
 from lazy_github.lib.messages import IssuesAndPullRequestsFetched, PullRequestSelected
 from lazy_github.lib.utils import bold, link, pluralize
-from lazy_github.models.github import FullPullRequest, PartialPullRequest
+from lazy_github.models.github import (
+    CheckStatus,
+    CheckStatusState,
+    FullPullRequest,
+    PartialPullRequest,
+)
+from lazy_github.ui.screens.lookup_pull_request import LookupPullRequestModal
 from lazy_github.ui.screens.new_comment import NewCommentModal
 from lazy_github.ui.widgets.common import LazilyLoadedDataTable, LazyGithubContainer
 from lazy_github.ui.widgets.conversations import IssueCommentContainer, ReviewContainer
@@ -31,6 +41,8 @@ class PullRequestsContainer(LazyGithubContainer):
     This container includes the primary datatable for viewing pull requests on the UI.
     """
 
+    BINDINGS = [LazyGithubBindings.LOOKUP_PULL_REQUEST]
+
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.pull_requests: dict[int, PartialPullRequest] = {}
@@ -50,6 +62,16 @@ class PullRequestsContainer(LazyGithubContainer):
             reverse_sort=True,
         )
 
+    @work
+    async def action_lookup_pull_request(self) -> None:
+        if pr := await self.app.push_screen_wait(LookupPullRequestModal()):
+            if pr.number not in self.pull_requests:
+                self.pull_requests[pr.number] = pr
+                self.searchable_table.append_rows([pull_request_to_cell(pr)])
+
+            self.post_message(PullRequestSelected(pr))
+            lg.info(f"Looked up PR #{pr.number}")
+
     async def fetch_more_pull_requests(self, batch_size: int, batch_to_fetch: int) -> list[tuple[str | int, ...]]:
         if not LazyGithubContext.current_repo:
             return []
@@ -117,12 +139,64 @@ class PrOverviewTabPane(TabPane):
     PrOverviewTabPane {
         overflow-y: auto;
     }
+
+    Collapsible {
+        height: auto;
+    }
+
+    ListView {
+        height: auto;
+    }
     """
 
+    BINDINGS = [LazyGithubBindings.MERGE_PULL_REQUEST]
+
     def __init__(self, pr: FullPullRequest) -> None:
         super().__init__("Overview", id="overview_pane")
         self.pr = pr
 
+    def _status_check_to_label(self, status: CheckStatus) -> str:
+        match status.state:
+            case CheckStatusState.SUCCESS:
+                status_summary = f"[green]{CHECKMARK} Passed[/green]"
+            case CheckStatusState.PENDING:
+                status_summary = "[yellow]... Pending[/yellow]"
+            case CheckStatusState.FAILURE:
+                status_summary = f"[red]{X_MARK} Failed[/red]"
+            case CheckStatusState.ERROR:
+                status_summary = f"[red]{X_MARK} Errored[/red]"
+
+        return f"{status_summary} {status.context} - {status.description}"
+
+    async def action_merge_pull_request(self) -> None:
+        if self.pr.merged_at is not None:
+            self.notify("PR has already been merged!", title="Already Merged", severity="warning")
+            return
+
+        try:
+            merge_result = await merge_pull_request(
+                self.pr, LazyGithubContext.config.pull_requests.preferred_merge_method
+            )
+            if merge_result.merged:
+                lg.info(f"Merged PR {self.pr.number} in repo {self.pr.repo.full_name}")
+                self.notify(
+                    f"Pull request {self.pr.number} merged. Note some cached information on the UI may be out of date.",
+                    title="PR Merged",
+                )
+
+                # This will force refetch the updated information about the PR for the UI
+                self.post_message(PullRequestSelected(self.pr))
+            else:
+                lg.warning(f"Failed to merge PR {self.pr.number} in repo {self.pr.repo.full_name}")
+                self.notify(
+                    f"Pull request {self.pr.number} could not be merged", title="Error Merging PR", severity="error"
+                )
+        except GithubApiRequestFailed:
+            lg.exception(f"Failed to merge PR {self.pr.number} in repo {self.pr.repo.full_name}")
+            self.notify(
+                f"Pull request {self.pr.number} could not be merged", title="Error Merging PR", severity="error"
+            )
+
     def compose(self) -> ComposeResult:
         pr_link = link(f"(#{self.pr.number})", self.pr.html_url)
         user_link = link(self.pr.user.login, self.pr.user.html_url)
@@ -157,10 +231,36 @@ class PrOverviewTabPane(TabPane):
             if self.pr.merged_at:
                 date = self.pr.merged_at.strftime("%c")
                 yield Label(f"\nMerged on {date}")
+            yield Rule()
+
+            # This is where we'll store information about the status checks being run on the PR
+            with Collapsible(title="Status Checks: ...", id="collapsible_status_checks") as c:
+                c.loading = True
+                # TODO: We should probably make this a table? That would allow follow-up actions to be performed as well
+                yield ListView(id="status_checks_list")
 
             yield Rule()
             yield Markdown(self.pr.body)
 
+    @work
+    async def load_checks(self) -> None:
+        # TODO: This should probably check normal check runs as well? Unsure if the combined check status includes all
+        # of those
+        combined_check_status = await combined_check_status_for_ref(self.pr.repo, self.pr.head.sha)
+        status_checks_list = self.query_one("#status_checks_list", ListView)
+        collapse_container = self.query_one("#collapsible_status_checks", Collapsible)
+        if statuses := combined_check_status.statuses:
+            status_labels = sorted(self._status_check_to_label(c) for c in statuses)
+            status_checks_list.extend(ListItem(Label(status_label)) for status_label in status_labels)
+            collapse_container.title = f"Status checks: {combined_check_status.state.value.title()}"
+        else:
+            collapse_container.title = "No status checks on PR"
+
+        collapse_container.loading = False
+
+    async def on_mount(self) -> None:
+        _ = self.load_checks()
+
 
 class PrDiffTabPane(TabPane):
     def __init__(self, pr: FullPullRequest) -> None:
@@ -172,7 +272,7 @@ class PrDiffTabPane(TabPane):
             yield RichLog(id="diff_contents", highlight=True)
 
     @work
-    async def fetch_diff(self):
+    async def fetch_diff(self) -> None:
         diff_contents = self.query_one("#diff_contents", RichLog)
         try:
             diff = await get_diff(self.pr)
@@ -185,9 +285,9 @@ class PrDiffTabPane(TabPane):
             diff_contents.write(diff)
         self.loading = False
 
-    def on_mount(self) -> None:
+    async def on_mount(self) -> None:
         self.loading = True
-        self.fetch_diff()
+        _ = self.fetch_diff()
 
 
 class PrConversationTabPane(TabPane):

{lazy_github-0.3.0 → lazy_github-0.3.2}/lazy_github/ui/widgets/repositories.py

@@ -28,7 +28,6 @@ class ReposContainer(LazyGithubContainer):
     BINDINGS = [
         LazyGithubBindings.TOGGLE_FAVORITE_REPO,
         LazyGithubBindings.LOOKUP_REPOSITORY,
-        # ("enter", "select"),
     ]
 
     def __init__(self, *args, **kwargs) -> None:

lazy_github-0.3.2/lazy_github/version.py

@@ -0,0 +1 @@
+VERSION = "0.3.2"

lazy_github-0.3.0/.github/workflows/publish.yaml

@@ -1,44 +0,0 @@
-name: Publish the package to pypi
-
-on: workflow_dispatch
-
-jobs:
-  pypi-publish:
-    name: Upload release to PyPI
-    runs-on: ubuntu-latest
-    environment:
-      name: pypi
-      url: https://pypi.org/p/lazy-github
-    permissions:
-      id-token: write
-    steps:
-      # Perform a bunch of setup
-    - uses: actions/checkout@v3
-    - uses: actions/setup-python@v4
-    - uses: yezz123/setup-uv@v4
-
-    - name: Calculate version
-      id: calculate-version
-      run: |
-        new_version=$((uvx hatch version))
-        echo "version=${new_version}" >> $GITHUB_OUTPUT
-
-      # Build the distribution
-    - name: Build lazy-github distribution
-      run: uvx hatch build
-
-    - name: Publish package distributions to PyPI
-      uses: pypa/gh-action-pypi-publish@release/v1
-
-    - name: Create tag
-      run: |
-        tag_name="v${{ steps.calculate-version.outputs.version }}"
-        git tag $tag_name && git push origin $tag_name
-
-    - name: Notify when this workflow completes (regardless of success or failure)
-      uses: nobrayner/discord-webhook@v1
-      with:
-        title: "Version ${{ steps.calculate-version.outputs.version }} published to PyPi"
-        description: "Check out the new version [here](https://pypi.org/project/lazy-github/${{ steps.calculate-version.outputs.version }}/)"
-        github-token: ${{ secrets.github_token }}
-        discord-webhook: ${{ secrets.DISCORD_WEBHOOK }}

lazy_github-0.3.0/lazy_github/version.py

@@ -1 +0,0 @@
-VERSION = "0.3.0"