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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazy-github
-Version: 0.6.0
+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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.2/lazy_github/lib/pr_drafts.py

@@ -0,0 +1,65 @@
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from lazy_github.lib.context import LazyGithubContext
+from lazy_github.lib.logging import lg
+
+
+@dataclass
+class PullRequestDraft:
+    repo_full_name: str
+    title: str
+    description: str
+    base_ref: str
+    head_ref: str
+    is_draft: bool
+    reviewers: list[str]
+
+
+def get_draft_path(repo_full_name: str) -> Path:
+    """Returns the path to the draft file for a given repository."""
+    safe_name = repo_full_name.replace("/", "_")
+    return LazyGithubContext.config.cache.cache_directory / "pr_drafts" / f"{safe_name}.json"
+
+
+def load_pr_draft(repo_full_name: str) -> PullRequestDraft | None:
+    """Load a PR draft for the given repository, returning None if not found or corrupt."""
+    draft_path = get_draft_path(repo_full_name)
+    if not draft_path.exists():
+        return None
+
+    try:
+        data = json.loads(draft_path.read_text())
+        return PullRequestDraft(**data)
+    except json.JSONDecodeError as e:
+        lg.warning(f"Failed to parse PR draft file '{draft_path}' as valid JSON: {e}. Ignoring draft.")
+        return None
+    except (TypeError, KeyError) as e:
+        lg.warning(f"PR draft file '{draft_path}' has invalid structure: {e}. Ignoring draft.")
+        return None
+    except Exception as e:
+        lg.warning(f"Unexpected error loading PR draft from '{draft_path}': {e}. Ignoring draft.")
+        return None
+
+
+def save_pr_draft(draft: PullRequestDraft) -> None:
+    """Save a PR draft to disk."""
+    draft_path = get_draft_path(draft.repo_full_name)
+    try:
+        draft_path.parent.mkdir(parents=True, exist_ok=True)
+        draft_path.write_text(json.dumps(asdict(draft), indent=2))
+        lg.debug(f"Saved PR draft to {draft_path}")
+    except Exception as e:
+        lg.warning(f"Failed to save PR draft to '{draft_path}': {e}")
+
+
+def clear_pr_draft(repo_full_name: str) -> None:
+    """Delete the draft file for the given repository."""
+    draft_path = get_draft_path(repo_full_name)
+    try:
+        if draft_path.exists():
+            draft_path.unlink()
+            lg.debug(f"Cleared PR draft at {draft_path}")
+    except Exception as e:
+        lg.warning(f"Failed to clear PR draft at '{draft_path}': {e}")

{lazy_github-0.6.0 → 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.0 → lazy_github-0.6.2}/lazy_github/ui/screens/create_or_edit_pull_request.py

@@ -5,6 +5,7 @@ from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical, VerticalScroll
 from textual.content import Content
 from textual.screen import ModalScreen
+from textual.timer import Timer
 from textual.types import DuplicateID
 from textual.widgets import Button, Input, Label, Markdown, Rule, SelectionList, Switch, TextArea
 from textual.widgets.selection_list import Selection
@@ -27,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
 
@@ -289,6 +291,7 @@ class CreateOrEditPullRequestContainer(VerticalScroll):
             "[yellow]Warning:[/yellow] Current local branch has no configured upstream", id="branch_missing"
         )
         self.branch_missing_label.display = False
+        self._draft_save_timer: Timer | None = None
 
     def compose(self) -> ComposeResult:
         pr_template = LazyGithubContext.config.pull_requests.pull_request_template
@@ -335,12 +338,96 @@ class CreateOrEditPullRequestContainer(VerticalScroll):
         if not does_branch_have_configured_upstream(LazyGithubContext.current_directory_branch):
             self.branch_missing_label.display = True
 
+    def _save_draft_state(self) -> None:
+        """Save the current form state as a draft, or clear if empty."""
+        if self.existing_pull_request or not LazyGithubContext.current_repo:
+            return
+
+        title = self.query_one("#pr_title", Input).value.strip()
+        description = self.query_one("#pr_description", TextArea).text.strip()
+        base_ref = self.query_one("#base_ref", Input).value
+        head_ref = self.query_one("#head_ref", Input).value
+        is_draft = self.query_one("#pr_is_draft", Switch).value
+        reviewers = list(self.query_one(ReviewerSelectionContainer).reviewers)
+
+        # If there's no meaningful content, clear any existing draft
+        if not title and not description and not reviewers:
+            clear_pr_draft(LazyGithubContext.current_repo.full_name)
+            return
+
+        draft = PullRequestDraft(
+            repo_full_name=LazyGithubContext.current_repo.full_name,
+            title=title,
+            description=description,
+            base_ref=base_ref,
+            head_ref=head_ref,
+            is_draft=is_draft,
+            reviewers=reviewers,
+        )
+        save_pr_draft(draft)
+
+    def _restore_draft_state(self) -> None:
+        """Restore form state from a saved draft if one exists."""
+        if self.existing_pull_request or not LazyGithubContext.current_repo:
+            return
+
+        draft = load_pr_draft(LazyGithubContext.current_repo.full_name)
+        if not draft:
+            return
+
+        # Check if draft has meaningful content
+        has_content = draft.title.strip() or draft.description.strip() or draft.reviewers
+
+        self.query_one("#pr_title", Input).value = draft.title
+        self.query_one("#pr_description", TextArea).text = draft.description
+        self.query_one("#base_ref", Input).value = draft.base_ref
+        self.query_one("#head_ref", Input).value = draft.head_ref
+        self.query_one("#pr_is_draft", Switch).value = draft.is_draft
+
+        reviewer_container = self.query_one(ReviewerSelectionContainer)
+        for reviewer in draft.reviewers:
+            reviewer_container.reviewers.add(reviewer)
+            try:
+                reviewer_container.reviewers_selection_list.add_option(
+                    Selection(reviewer, reviewer, id=reviewer, initial_state=True)
+                )
+            except DuplicateID:
+                pass
+        if draft.reviewers:
+            reviewer_container.current_reviewers_label.display = True
+            reviewer_container.reviewers_selection_list.display = True
+
+        if has_content:
+            self.notify("Restored saved PR draft")
+
     async def on_mount(self) -> None:
         self.query_one("#pr_title", Input).focus()
         self.ensure_directory_branch_has_configured_upstream()
+        if not self.existing_pull_request:
+            self._restore_draft_state()
+
+    def _schedule_draft_save(self) -> None:
+        """Schedule a debounced draft save after 2 seconds of inactivity."""
+        if self.existing_pull_request:
+            return
+        if self._draft_save_timer is not None:
+            self._draft_save_timer.stop()
+        self._draft_save_timer = self.set_timer(2, self._save_draft_state)
+
+    @on(Input.Changed, "#pr_title")
+    @on(Input.Changed, "#base_ref")
+    @on(Input.Changed, "#head_ref")
+    def _on_input_changed(self, _: Input.Changed) -> None:
+        self._schedule_draft_save()
+
+    @on(TextArea.Changed, "#pr_description")
+    def _on_description_changed(self, _: TextArea.Changed) -> None:
+        self._schedule_draft_save()
 
     @on(Button.Pressed, "#cancel_new_pr")
     def cancel_pull_request(self, _: Button.Pressed):
+        if not self.existing_pull_request:
+            self._save_draft_state()
         self.app.pop_screen()
 
     async def _edit_pr(self) -> None:
@@ -418,6 +505,7 @@ class CreateOrEditPullRequestContainer(VerticalScroll):
             lg.info(f"Requesting PR reviews from: {', '.join(reviewers)}")
             await request_reviews(created_pr, reviewers)
 
+        clear_pr_draft(LazyGithubContext.current_repo.full_name)
         self.notify("Successfully created PR!")
         self.post_message(PullRequestCreatedOrUpdated(created_pr))
 
@@ -461,6 +549,9 @@ class CreateOrEditPullRequestModal(ModalScreen[FullPullRequest | None]):
         yield CreateOrEditPullRequestContainer(self.existing_pull_request)
 
     def action_close(self) -> None:
+        if not self.existing_pull_request:
+            container = self.query_one(CreateOrEditPullRequestContainer)
+            container._save_draft_state()
         self.dismiss(None)
 
     @on(PullRequestCreatedOrUpdated)

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.0 → 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)
@@ -480,9 +480,19 @@ class LazyGithubMainScreen(Screen):
 
     async def action_toggle_ui(self, ui_to_hide: str):
         widget = self.query_one(f"#{ui_to_hide}", Widget)
-        new_value = not widget.visible
-        widget.display = not new_value
-        widget.visible = not new_value
+        new_value = not widget.display
+        widget.display = new_value
+        widget.visible = new_value
+
+        # If showing a section and we have a repo loaded, refresh its data
+        if new_value and LazyGithubContext.current_repo:
+            repo = LazyGithubContext.current_repo
+            selections = self.main_view_pane.selections
+            if ui_to_hide == "workflows":
+                selections.workflows.initialize_tables_from_cache(repo)
+                selections.workflows.load_repo(repo)
+            elif ui_to_hide in ("issues", "pull_requests"):
+                selections.fetch_issues_and_pull_requests(repo)
 
     async def action_show_settings_modal(self) -> None:
         self.app.push_screen(SettingsModal())