lazy-github 0.6.1__tar.gz → 0.6.2__tar.gz

{lazy_github-0.6.1 → lazy_github-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazy-github
-Version: 0.6.1
+Version: 0.6.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.6.1 → lazy_github-0.6.2}/lazy_github/cli.py

@@ -55,10 +55,14 @@ def clear_auth():
 
 
 @cli.command
-def clear_config():
+@click.option("--no-confirm", is_flag=True, default=False, help="Don't ask for confirmation")
+def clear_config(no_confirm: bool):
     """Reset the user's settings"""
-    _CONFIG_FILE_LOCATION.unlink(missing_ok=True)
-    print("Your settings have been cleared")
+    if no_confirm or click.confirm("Confirm deletion your LazyGithub settings"):
+        _CONFIG_FILE_LOCATION.unlink(missing_ok=True)
+        print("Your settings have been cleared")
+    else:
+        print("Canceling")
 
 
 @cli.command
@@ -80,3 +84,11 @@ def clear_cache(no_confirm: bool):
 def debug():
     """Outputs LazyGithub debug info"""
     print(collect_debug_info())
+
+
+@cli.command
+def version():
+    """Prints the current version"""
+    from lazy_github.version import VERSION
+
+    print(f"LazyGithub version {VERSION}")

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/lib/bindings.py

@@ -38,6 +38,13 @@ class LazyGithubBindings:
         "I", "open_issue", "New Issue", id="issue.new", tooltip="Open a new issue in the current repository"
     )
     EDIT_ISSUE = Binding("E", "edit_issue", "Edit Issue", id="issue.edit", tooltip="Edit the selected issue")
+    LOOKUP_ISSUE = Binding(
+        "O",
+        "lookup_issue",
+        "Lookup Issue",
+        id="issue.lookup",
+        tooltip="Lookup an issue in the current repository",
+    )
 
     # Pull request actions
     OPEN_PULL_REQUEST = Binding(

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/lib/github/backends/cli.py

@@ -101,7 +101,7 @@ def _create_request_body_tempfile(body: bytes) -> tempfile._TemporaryFileWrapper
     _TEMPORARY_JSON_BODY_DIRECTORY.mkdir(parents=True, exist_ok=True)
     if sys.version_info.minor > 11:
         # delete_on_close parameter added in Python 3.12
-        temp = tempfile.NamedTemporaryFile(delete=False, delete_on_close=False, dir=_TEMPORARY_JSON_BODY_DIRECTORY)  # type: ignore[call-arg]
+        temp = tempfile.NamedTemporaryFile(delete=False, delete_on_close=False, dir=_TEMPORARY_JSON_BODY_DIRECTORY)
     else:
         temp = tempfile.NamedTemporaryFile(delete=False, dir=_TEMPORARY_JSON_BODY_DIRECTORY)
     temp.write(body)

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/lib/github/issues.py

@@ -7,6 +7,14 @@ from lazy_github.models.github import Issue, IssueComment, PartialPullRequest, R
 DEFAULT_PAGE_SIZE = 30
 
 
+async def get_issue_by_number(repo: Repository, issue_number: int) -> Issue:
+    """Looks up a single issue by number in the given repository"""
+    url = f"/repos/{repo.owner.login}/{repo.name}/issues/{issue_number}"
+    response = await LazyGithubContext.client.get(url, headers=github_headers())
+    response.raise_for_status()
+    return Issue(**response.json(), repo=repo)
+
+
 class UpdateIssuePayload(TypedDict):
     title: str | None
     body: str | None

lazy_github-0.6.2/lazy_github/lib/github/reactions.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+from lazy_github.lib.context import LazyGithubContext, github_headers
+from lazy_github.models.github import Issue, IssueComment, Reaction, ReactionSet, ReactionType, Repository, User
+
+
+def _build_reaction_set(response: Any) -> ReactionSet:
+    response.raise_for_status()
+    reaction_users: dict[ReactionType, list[User]] = {}
+    reaction_counts: dict[ReactionType, int] = {}
+
+    for raw_reaction in response.json():
+        reaction_type = ReactionType.from_github(raw_reaction["content"])
+        reaction_users.setdefault(reaction_type, [])
+        reaction_counts.setdefault(reaction_type, 0)
+
+        user = User(**raw_reaction["user"])
+        reaction_users[reaction_type].append(user)
+        reaction_counts[reaction_type] += 1
+
+    return ReactionSet(reaction_users=reaction_users, reaction_counts=reaction_counts)
+
+
+async def list_reactions_on_comment(repo: Repository, comment: IssueComment) -> ReactionSet:
+    url = f"/repos/{repo.full_name}/issues/comments/{comment.id}/reactions"
+    response = await LazyGithubContext.client.get(url, headers=github_headers())
+    return _build_reaction_set(response)
+
+
+async def add_reaction_on_comment(repo: Repository, comment: IssueComment, reaction: ReactionType) -> Reaction:
+    url = f"/repos/{repo.full_name}/issues/comments/{comment.id}/reactions"
+    body = {"content": reaction.name.lower()}
+    response = await LazyGithubContext.client.post(url, headers=github_headers(), json=body)
+    response.raise_for_status()
+    return Reaction(**response.json())
+
+
+async def list_reactions_on_issue(repo: Repository, issue: Issue) -> ReactionSet:
+    url = f"/repos/{repo.full_name}/issues/{issue.number}/reactions"
+    response = await LazyGithubContext.client.get(url, headers=github_headers())
+    return _build_reaction_set(response)

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/lib/messages.py

@@ -9,18 +9,26 @@ from lazy_github.models.github import (
     IssueComment,
     Notification,
     PartialPullRequest,
+    ReactionSet,
     Repository,
     Review,
     WorkflowRun,
 )
 
 
-class ReviewsLoaded(Message):
-    """A message sent when reviews for a pull request have been loaded"""
+class ReviewsAndCommentsLoaded(Message):
+    """A message sent when reviews and comments for a pull request have been loaded"""
 
-    def __init__(self, reviews: list[Review]) -> None:
+    def __init__(self, reviews: list[Review], comments: list[IssueComment]) -> None:
         super().__init__()
         self.reviews = reviews
+        self.comments = comments
+
+
+class CommentReactionsLoaded(Message):
+    def __init__(self, reactions: dict[int, ReactionSet]) -> None:
+        super().__init__()
+        self.reactions = reactions
 
 
 class RepoSelected(Message):

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/lib/pr_drafts.py

@@ -1,5 +1,5 @@
 import json
-from dataclasses import dataclass, asdict
+from dataclasses import asdict, dataclass
 from pathlib import Path
 
 from lazy_github.lib.context import LazyGithubContext

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/models/github.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from enum import StrEnum
+from enum import Enum, StrEnum
 
 from pydantic import BaseModel, Field
 
@@ -302,3 +302,44 @@ class CheckStatus(BaseModel):
 class CombinedCheckStatus(BaseModel):
     state: CheckStatusState
     statuses: list[CheckStatus]
+
+
+class ReactionType(Enum):
+    def __init__(self, value: str, emoji: str) -> None:
+        super().__init__()
+        self._value = value
+        self.emoji = emoji
+
+    @classmethod
+    def from_github(cls, github_content: str) -> "ReactionType":
+        try:
+            return cls[github_content.upper()]
+        except KeyError:
+            if github_content == "+1":
+                return ReactionType.THUMBS_UP
+            elif github_content == "-1":
+                return ReactionType.THUMBS_DOWN
+            else:
+                raise ValueError(f"Invalid reaction string: {github_content}")
+
+    THUMBS_UP = ("+1", "👍")
+    THUMBS_DOWN = ("-1", "👎")
+    LAUGH = ("laugh", "😄")
+    CONFUSED = ("confused", "😕")
+    HEART = ("heart", "❤️")
+    HOORAY = ("hooray", "🎉")
+    ROCKET = ("rocket", "🚀")
+    EYES = ("eyes", "👀")
+
+
+class Reaction(BaseModel):
+    reaction_type: ReactionType
+    user: User
+
+
+class ReactionSet(BaseModel):
+    reaction_users: dict[ReactionType, list[User]]
+    reaction_counts: dict[ReactionType, int]
+
+    def __bool__(self) -> bool:
+        return bool(self.reaction_counts) or bool(self.reaction_users)

lazy_github-0.6.2/lazy_github/ui/screens/lookup_issue.py

@@ -0,0 +1,89 @@
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.content import Content
+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.issues import get_issue_by_number
+from lazy_github.models.github import Issue
+from lazy_github.ui.widgets.common import LazyGithubFooter
+
+
+class LookupIssueButtons(Horizontal):
+    DEFAULT_CSS = """
+    LookupIssueButtons {
+        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 LookupIssueContainer(Container):
+    DEFAULT_CSS = """
+    LookupIssueContainer {
+        align: center middle;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Markdown("# Search for an issue by number:")
+        yield Label(Content.from_markup("[bold]Issue Number:[/bold]"))
+        yield Input(
+            id="issue_number",
+            placeholder="Issue number",
+            type="number",
+        )
+        yield Rule()
+        yield LookupIssueButtons()
+
+
+class LookupIssueModal(ModalScreen[Issue | None]):
+    DEFAULT_CSS = """
+    LookupIssueModal {
+        align: center middle;
+        content-align: center middle;
+    }
+
+    LookupIssueContainer {
+        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 LookupIssueContainer()
+        yield LazyGithubFooter()
+
+    @on(Button.Pressed, "#lookup")
+    async def action_submit(self) -> None:
+        assert LazyGithubContext.current_repo is not None, "Current repo is missing!"
+
+        try:
+            issue_number = int(self.query_one("#issue_number", Input).value)
+            issue = await get_issue_by_number(LazyGithubContext.current_repo, issue_number)
+        except ValueError:
+            self.notify("Must enter a valid issue number!", title="Invalid Issue Number", severity="error")
+        except GithubApiRequestFailed:
+            self.notify("Could not find issue!", title="Unknown Issue", severity="error")
+        else:
+            self.dismiss(issue)
+
+    @on(Button.Pressed, "#cancel")
+    async def action_close(self) -> None:
+        self.dismiss(None)

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/ui/screens/primary.py

@@ -30,7 +30,7 @@ from lazy_github.lib.messages import (
     IssueSelected,
     PullRequestSelected,
     RepoSelected,
-    ReviewsLoaded,
+    ReviewsAndCommentsLoaded,
     WorkflowRunSelected,
 )
 from lazy_github.models.github import Issue, PartialPullRequest, Repository, WorkflowRun
@@ -333,11 +333,11 @@ class MainViewPane(Container):
         if focus_run_details:
             tabbed_content.children[0].focus()
 
-    @on(ReviewsLoaded)
-    async def handle_reviews_loaded(self, message: ReviewsLoaded) -> None:
+    @on(ReviewsAndCommentsLoaded)
+    async def handle_reviews_loaded(self, message: ReviewsAndCommentsLoaded) -> None:
         try:
             overview_pane = self.query_one(PrOverviewTabPane)
-        except WrongType | NoMatches:
+        except (WrongType, NoMatches):
             pass
         else:
             overview_pane.add_reviews(message.reviews)

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/ui/widgets/conversations.py

@@ -2,15 +2,77 @@ from textual import work
 from textual.app import ComposeResult
 from textual.containers import Container
 from textual.content import Content
-from textual.widgets import Collapsible, Label, Markdown
+from textual.widgets import Collapsible, Label, ListItem, ListView, Markdown, Static
 
 from lazy_github.lib.bindings import LazyGithubBindings
 from lazy_github.lib.github.pull_requests import ReviewCommentNode
 from lazy_github.lib.messages import NewCommentCreated
-from lazy_github.models.github import FullPullRequest, Issue, IssueComment, Review, ReviewComment, ReviewState
+from lazy_github.models.github import (
+    FullPullRequest,
+    Issue,
+    IssueComment,
+    ReactionSet,
+    Review,
+    ReviewComment,
+    ReviewState,
+)
 from lazy_github.ui.screens.new_comment import NewCommentModal
 
 
+class ReactionsDisplay(Container):
+    DEFAULT_CSS = """
+    ReactionsDisplay {
+        height: auto;
+    }
+    Collapsible {
+        height: auto;
+    }
+
+    ListView {
+        height: auto;
+    }
+    """
+
+    def __init__(self, item_id: str | int, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self.item_id = item_id
+
+    @property
+    def reactions_list(self) -> ListView:
+        return self.query_one(f"#reactions_list_{self.item_id}", ListView)
+
+    @property
+    def collapsible_reactions(self) -> Collapsible:
+        return self.query_one(f"#collapsible_reactions_{self.item_id}", Collapsible)
+
+    def compose(self) -> ComposeResult:
+        with Collapsible(title="Reactions...", id=f"collapsible_reactions_{self.item_id}", collapsed=True):
+            yield ListView(id=f"reactions_list_{self.item_id}")
+
+    def on_mount(self) -> None:
+        self.loading = True
+
+    async def set_reactions(self, reactions: ReactionSet) -> None:
+        self.loading = True
+        await self.reactions_list.clear()
+        summary_strings = [f"{rt.emoji} {count}" for rt, count in reactions.reaction_counts.items() if count]
+
+        for reaction_type, users in reactions.reaction_users.items():
+            if not users:
+                continue
+            elif len(users) > 3:
+                users_string = f"{users[0].login}, {users[1].login}, {users[2].login}, and {len(users) - 3} more"
+            else:
+                users_string = ", ".join(u.login for u in users)
+
+            reaction_label = f"{reaction_type.emoji}: {users_string}"
+            self.reactions_list.append(ListItem(Label(Content.from_markup(reaction_label))))
+
+        self.loading = False
+        self.collapsible_reactions.title = " | ".join(summary_strings)
+        self.collapsible_reactions.display = bool(summary_strings)
+
+
 class IssueCommentContainer(Container, can_focus=True):
     DEFAULT_CSS = """
     IssueCommentContainer {
@@ -60,6 +122,15 @@ class IssueCommentContainer(Container, can_focus=True):
     def action_reply_to_individual_comment(self) -> None:
         self.reply_to_comment_flow()
 
+    async def add_reaction_display(self, reactions: ReactionSet) -> None:
+        # Add the reactions to the bottom of each comment display
+        if not reactions:
+            return
+
+        rd = ReactionsDisplay(self.comment.id)
+        await self.children[-1].mount(rd)
+        await rd.set_reactions(reactions)
+
 
 class ReviewConversation(Container):
     DEFAULT_CSS = """
@@ -86,12 +157,16 @@ class ReviewConversation(Container):
             yield IssueCommentContainer(self.pr, comment)
 
 
-class ReviewContainer(Collapsible, can_focus=True):
+class ReviewContainer(Container):
     DEFAULT_CSS = """
     ReviewContainer {
         height: auto;
     }
 
+    Collapsible {
+        height: auto;
+    }
+
     ReviewContainer:focus-within {
         border: solid $success-lighten-3;
     }
@@ -111,15 +186,19 @@ class ReviewContainer(Collapsible, can_focus=True):
             review_state_text = "[red]Changes Requested[/red]"
         else:
             review_state_text = self.review.state.title()
+        review_summary = f"Review from {self.review.user.login} ({review_state_text})"
 
-        yield Label(Content.from_markup(f"Review from {self.review.user.login} ({review_state_text})"))
-
-        if self.review.body:
-            yield Markdown(self.review.body)
+        if self.review.body or self.review.comments:
+            with Collapsible(title=review_summary, collapsed=self.review.state == ReviewState.DISMISSED):
+                if self.review.body:
+                    yield Markdown(self.review.body)
 
-        for comment in self.review.comments:
-            if comment_node := self.hierarchy.get(comment.id):
-                yield ReviewConversation(self.pr, comment_node)
+                for comment in self.review.comments:
+                    if comment_node := self.hierarchy.get(comment.id):
+                        yield ReviewConversation(self.pr, comment_node)
+        else:
+            with Collapsible(title=review_summary, collapsed=True):
+                yield Static("No additional review content")
 
     def action_reply_to_review(self) -> None:
         self.app.push_screen(NewCommentModal(self.pr.repo, self.pr, self.review))

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/ui/widgets/issues.py

@@ -15,6 +15,7 @@ from lazy_github.lib.logging import lg
 from lazy_github.lib.messages import IssuesAndPullRequestsFetched, IssueSelected, NewCommentCreated
 from lazy_github.models.github import Issue, IssueState, PartialPullRequest, Repository
 from lazy_github.ui.screens.edit_issue import EditIssueModal
+from lazy_github.ui.screens.lookup_issue import LookupIssueModal
 from lazy_github.ui.screens.new_comment import NewCommentModal
 from lazy_github.ui.widgets.common import LazilyLoadedDataTable, LazyGithubContainer, TableRow
 from lazy_github.ui.widgets.conversations import IssueCommentContainer
@@ -25,7 +26,7 @@ def issue_to_cell(issue: Issue) -> TableRow:
 
 
 class IssuesContainer(LazyGithubContainer):
-    BINDINGS = [LazyGithubBindings.EDIT_ISSUE]
+    BINDINGS = [LazyGithubBindings.LOOKUP_ISSUE, LazyGithubBindings.EDIT_ISSUE]
 
     issues: Dict[int, Issue] = {}
     status_column_index = -1
@@ -80,8 +81,6 @@ class IssuesContainer(LazyGithubContainer):
         self.number_column_index = self.table.get_column_index("number")
         self.title_column_index = self.table.get_column_index("title")
 
-        self.searchable_table.loading = True
-
     def load_cached_issues_for_repo(self, repo: Repository) -> None:
         self.searchable_table.loading = True
         self.searchable_table.initialize_from_cache(repo, Issue)
@@ -112,6 +111,15 @@ class IssuesContainer(LazyGithubContainer):
     async def action_edit_issue(self) -> None:
         self.trigger_edit_issue_flow()
 
+    @work
+    async def action_lookup_issue(self) -> None:
+        if issue := await self.app.push_screen_wait(LookupIssueModal()):
+            if not self.searchable_table.item_in_table(issue):
+                self.searchable_table.add_item(issue)
+
+            self.post_message(IssueSelected(issue))
+            lg.info(f"Looked up Issue #{issue.number}")
+
     @on(DataTable.RowSelected, "#issues_table")
     async def issue_selected(self) -> None:
         issue = await self.get_selected_issue()

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/ui/widgets/pull_requests.py

@@ -1,3 +1,6 @@
+import asyncio
+from typing import Any, Coroutine
+
 from httpx import HTTPStatusError
 from textual import on, work
 from textual.app import ComposeResult
@@ -28,16 +31,20 @@ from lazy_github.lib.github.pull_requests import (
     merge_pull_request,
     reconstruct_review_conversation_hierarchy,
 )
+from lazy_github.lib.github.reactions import list_reactions_on_comment, list_reactions_on_issue
 from lazy_github.lib.logging import lg
 from lazy_github.lib.messages import (
+    CommentReactionsLoaded,
     IssuesAndPullRequestsFetched,
     PullRequestSelected,
-    ReviewsLoaded,
+    ReviewsAndCommentsLoaded,
 )
 from lazy_github.models.github import (
     CheckStatus,
     FullPullRequest,
+    IssueComment,
     PartialPullRequest,
+    ReactionSet,
     Repository,
     Review,
     ReviewState,
@@ -52,7 +59,7 @@ from lazy_github.ui.widgets.common import (
     LazyGithubContainer,
     TableRow,
 )
-from lazy_github.ui.widgets.conversations import IssueCommentContainer, ReviewContainer
+from lazy_github.ui.widgets.conversations import IssueCommentContainer, ReactionsDisplay, ReviewContainer
 from lazy_github.ui.widgets.diff_viewer import DiffViewerContainer
 
 
@@ -145,8 +152,6 @@ class PullRequestsContainer(LazyGithubContainer):
         self.number_column_index = self.table.get_column_index("number")
         self.title_column_index = self.table.get_column_index("title")
 
-        self.searchable_table.loading = True
-
     async def on_issues_and_pull_requests_fetched(self, message: IssuesAndPullRequestsFetched) -> None:
         message.stop()
 
@@ -197,6 +202,24 @@ class PrOverviewTabPane(TabPane):
         super().__init__("Overview", id="overview_pane")
         self.pr = pr
 
+    @property
+    def collapsible_status_checks(self) -> Collapsible:
+        return self.query_one("#collapsible_status_checks", Collapsible)
+
+    @property
+    def collapsible_reviews(self) -> Collapsible:
+        return self.query_one("#collapsible_reviews", Collapsible)
+
+    @property
+    def pr_reactions(self) -> ReactionsDisplay:
+        return self.query_one("#pr_reactions", ReactionsDisplay)
+
+    def on_mount(self) -> None:
+        self.collapsible_status_checks.loading = True
+        self.collapsible_reviews.loading = True
+        self.load_checks()
+        self.load_reactions()
+
     def _status_check_to_label(self, status: CheckStatus) -> str:
         status_summary = status.state.to_display()
         return f"{status_summary} {status.context} - {status.description}"
@@ -280,30 +303,24 @@ class PrOverviewTabPane(TabPane):
                 merged_date = self.pr.merged_at.strftime("%c")
                 date_text += f" • Merged on {merged_date}"
             yield Label(Content.from_markup(date_text))
-            yield Rule()
 
-            # This is where we'll store information about the status checks being run on the PR
+            yield ReactionsDisplay(self.pr.id, id="pr_reactions")
+
             with Collapsible(title="Status Checks: ...", id="collapsible_status_checks"):
                 yield ListView(id="status_checks_list")
 
-            # This is where we'll store information about the PR reviews
             with Collapsible(title="Reviews: ...", id="collapsible_reviews"):
                 yield ListView(id="reviews_list")
 
             yield Rule()
             yield Markdown(self.pr.body)
 
-    def on_mount(self) -> None:
-        self.query_one("#collapsible_status_checks", Collapsible).loading = True
-        self.query_one("#collapsible_reviews", Collapsible).loading = True
-        self.load_checks()
-
     @work
     async def add_reviews(self, reviews: list[Review]) -> None:
-        reviews_collapsible_container = self.query_one("#collapsible_reviews", Collapsible)
         if not reviews:
-            reviews_collapsible_container.title = "No reviews"
-            reviews_collapsible_container.loading = False
+            self.collapsible_reviews.title = "No reviews"
+            self.collapsible_reviews.display = False
+            self.collapsible_reviews.loading = False
             return
 
         reviews_list = self.query_one("#reviews_list", ListView)
@@ -323,12 +340,21 @@ class PrOverviewTabPane(TabPane):
         reviews_list.extend(ListItem(Label(Content.from_markup(self._review_to_label(r)))) for r in latest_reviews)
 
         if all(r.state == ReviewState.APPROVED for r in latest_reviews):
-            reviews_collapsible_container.title = f"PR Reviews: {ReviewState.APPROVED.to_display()}"
+            self.collapsible_reviews.title = f"PR Reviews: {ReviewState.APPROVED.to_display()}"
         elif any(r.state == ReviewState.CHANGES_REQUESTED for r in latest_reviews):
-            reviews_collapsible_container.title = f"PR Reviews: {ReviewState.CHANGES_REQUESTED.to_display()}"
+            self.collapsible_reviews.title = f"PR Reviews: {ReviewState.CHANGES_REQUESTED.to_display()}"
         else:
-            reviews_collapsible_container.title = "PR Reviews Summary"
-        reviews_collapsible_container.loading = False
+            self.collapsible_reviews.title = "PR Reviews Summary"
+        self.collapsible_reviews.loading = False
+        self.collapsible_reviews.display = True
+
+    @work
+    async def load_reactions(self) -> None:
+        try:
+            reactions = await list_reactions_on_issue(self.pr.repo, self.pr)
+            await self.pr_reactions.set_reactions(reactions)
+        except Exception as e:
+            lg.exception(f"Error loading reactions data: {e}")
 
     @work
     async def load_checks(self) -> None:
@@ -336,18 +362,19 @@ class PrOverviewTabPane(TabPane):
         # 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(Content.from_markup(status_label))) for status_label in status_labels
             )
 
-            collapse_container.title = f"Status checks: {combined_check_status.state.to_display()}"
+            self.collapsible_status_checks.title = f"Status checks: {combined_check_status.state.to_display()}"
+            self.collapsible_status_checks.display = True
         else:
-            collapse_container.title = "No status checks on PR"
+            self.collapsible_status_checks.title = "No status checks on PR"
+            self.collapsible_status_checks.display = False
 
-        collapse_container.loading = False
+        self.collapsible_status_checks.loading = False
 
 
 class PrDiffTabPane(TabPane):
@@ -385,6 +412,7 @@ class PrConversationTabPane(TabPane):
     def __init__(self, pr: FullPullRequest) -> None:
         super().__init__("Conversation", id="conversation_pane")
         self.pr = pr
+        self.comment_containers: dict[str, IssueCommentContainer] = {}
 
     def compose(self) -> ComposeResult:
         yield VerticalScroll(id="pr_comments_and_reviews")
@@ -393,33 +421,81 @@ class PrConversationTabPane(TabPane):
     def comments_and_reviews(self) -> VerticalScroll:
         return self.query_one("#pr_comments_and_reviews", VerticalScroll)
 
-    @on(ReviewsLoaded)
-    async def handle_reviews_loaded(self, message: ReviewsLoaded) -> None:
+    @on(ReviewsAndCommentsLoaded)
+    async def handle_reviews_loaded(self, message: ReviewsAndCommentsLoaded) -> None:
         review_hierarchy = reconstruct_review_conversation_hierarchy(message.reviews)
-        comments = await get_comments(self.pr)
         self.comments_and_reviews.remove_children()
 
         handled_comment_node_ids: list[int] = []
         for review in message.reviews:
+            if not review.body and review.state == ReviewState.COMMENTED:
+                continue
             if review.body:
                 handled_comment_node_ids.extend([c.id for c in review.comments])
             review_container = ReviewContainer(self.pr, review, review_hierarchy)
             self.comments_and_reviews.mount(review_container)
 
-        for comment in comments:
+        for comment in message.comments:
             if comment.body and comment.id not in handled_comment_node_ids:
                 comment_container = IssueCommentContainer(self.pr, comment)
                 self.comments_and_reviews.mount(comment_container)
 
         if len(self.comments_and_reviews.children) == 0:
             self.comments_and_reviews.mount(Label("No reviews or comments available"))
+            self.comments_and_reviews.display = False
+        else:
+            self.comments_and_reviews.display = True
+
+        self.comment_containers: dict[str, IssueCommentContainer] = {}
+        for container in self.query(IssueCommentContainer):
+            self.comment_containers[str(container.comment.id)] = container
+
+        self.fetch_reactions(self.pr.repo, message.reviews, message.comments)
 
         self.loading = False
 
+    @on(CommentReactionsLoaded)
+    async def handle_comment_reactions_loaded(self, message: CommentReactionsLoaded) -> None:
+        tasks: list[Coroutine[Any, Any, None]] = []
+        for comment_id, reactions in message.reactions.items():
+            if comment := self.comment_containers.get(str(comment_id)):
+                tasks.append(comment.add_reaction_display(reactions))
+
+        await asyncio.gather(*tasks)
+
+    @work
+    async def fetch_reactions(self, repo: Repository, reviews: list[Review], comments: list[IssueComment]) -> None:
+        """
+        Loads any reactions on the specified comments or on comments within the specified reviews. Posts a
+        `CommentReactionsLoaded` message after completion.
+        """
+        comment_reactions: dict[int, ReactionSet] = {}
+
+        async def _get_comment_reactions(comment: IssueComment) -> None:
+            try:
+                comment_reactions[comment.id] = await list_reactions_on_comment(repo, comment)
+            except GithubApiRequestFailed:
+                lg.debug(f"Could not find comment with ID {comment.id}")
+
+        tasks: list[Coroutine[Any, Any, None]] = []
+        tasks.extend(_get_comment_reactions(comment) for comment in comments)
+        for review in reviews:
+            tasks.extend(_get_comment_reactions(comment) for comment in review.comments)
+
+        await asyncio.gather(*tasks)
+        self.post_message(CommentReactionsLoaded(comment_reactions))
+
     @work
     async def fetch_conversation(self) -> None:
-        reviews = await get_reviews(self.pr)
-        self.post_message(ReviewsLoaded(reviews))
+        reviews_coro = get_reviews(self.pr)
+        comments_coro = get_comments(self.pr)
+
+        try:
+            reviews, comments = await reviews_coro, await comments_coro
+        except GithubApiRequestFailed:
+            lg.error("Error retrieving PR reviews or comments")
+        else:
+            self.post_message(ReviewsAndCommentsLoaded(reviews, comments))
 
     def on_mount(self) -> None:
         self.loading = True

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/ui/widgets/workflows.py

@@ -59,8 +59,6 @@ class WorkflowRunsContainer(Container):
 
         self.run_number_column_id = self.table.get_column_index("run_number")
 
-        self.searchable_table.loading = True
-
     def load_cached_workflow_runs(self, repo: Repository) -> None:
         self.searchable_table.loading = True
         self.searchable_table.initialize_from_cache(repo, WorkflowRun)

lazy_github-0.6.2/lazy_github/version.py

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

lazy_github-0.6.2/lint.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+uv sync --quiet
+uvx ruff check --select I --fix --quiet
+uvx ruff check --fix --quiet
+uvx ty check --quiet

lazy_github-0.6.1/lazy_github/version.py

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

lazy_github-0.6.1/lint.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-
-uv sync
-uv run ruff check --select I --fix
-uv run ruff check --fix
-uv run pyright

{lazy_github-0.6.1 → lazy_github-0.6.2}/lazy_github/ui/screens/create_or_edit_pull_request.py

@@ -18,7 +18,6 @@ from lazy_github.lib.git_cli import (
     push_branch_to_remote,
 )
 from lazy_github.lib.github.branches import list_branches
-from lazy_github.lib.pr_drafts import PullRequestDraft, clear_pr_draft, load_pr_draft, save_pr_draft
 from lazy_github.lib.github.pull_requests import (
     create_pull_request,
     list_requested_reviewers,
@@ -29,6 +28,7 @@ from lazy_github.lib.github.repositories import get_collaborators
 from lazy_github.lib.github.users import get_user_by_username
 from lazy_github.lib.logging import lg
 from lazy_github.lib.messages import BranchesLoaded, PullRequestCreatedOrUpdated
+from lazy_github.lib.pr_drafts import PullRequestDraft, clear_pr_draft, load_pr_draft, save_pr_draft
 from lazy_github.models.github import Branch, FullPullRequest, PartialPullRequest
 from lazy_github.ui.screens.confirm import ConfirmDialog