lazy-github 0.1.7__tar.gz → 0.2__tar.gz

{lazy_github-0.1.7 → lazy_github-0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lazy-github
-Version: 0.1.7
+Version: 0.2
 Summary: A terminal UI for interacting with Github
 Author-email: Chris Chapline <gizmo385@users.noreply.github.com>
 Maintainer-email: Chris Chapline <gizmo385@users.noreply.github.com>
@@ -47,7 +47,7 @@ inspiration from the [lazygit](https://github.com/jesseduffield/lazygit) project
 [Textual](https://textual.textualize.io/) to drive the terminal UI interactions.
 
 
-![Example screenshot](./images/lazy-github-conversation-ui.svg)
+![Example screenshot](https://raw.githubusercontent.com/gizmo385/lazy-github/main/images/lazy-github-conversation-ui.svg)
 
 
 Currently, it supports the following:

{lazy_github-0.1.7 → lazy_github-0.2}/README.md

@@ -5,7 +5,7 @@ inspiration from the [lazygit](https://github.com/jesseduffield/lazygit) project
 [Textual](https://textual.textualize.io/) to drive the terminal UI interactions.
 
 
-![Example screenshot](./images/lazy-github-conversation-ui.svg)
+![Example screenshot](https://raw.githubusercontent.com/gizmo385/lazy-github/main/images/lazy-github-conversation-ui.svg)
 
 
 Currently, it supports the following:

{lazy_github-0.1.7 → lazy_github-0.2}/lazy_github/cli.py

@@ -1,12 +1,16 @@
 import click
+import rich
+import shutil
 
 from lazy_github.lib.config import _CONFIG_FILE_LOCATION, Config
+from lazy_github.lib.context import LazyGithubContext
 from lazy_github.ui.app import app
 
 
 @click.group(invoke_without_command=True)
 @click.pass_context
 def cli(ctx: click.Context) -> None:
+    """A Terminal UI for interacting with Github"""
     if ctx.invoked_subcommand is None:
         run()
 
@@ -21,7 +25,7 @@ def run():
 def dump_config():
     """Dump the current configuration, as it would be loaded by LazyGithub"""
     print(f"Config file location: {_CONFIG_FILE_LOCATION} (exists => {_CONFIG_FILE_LOCATION.exists()})")
-    print(Config.load_config().model_dump_json(indent=4))
+    rich.print_json(Config.load_config().model_dump_json())
 
 
 @cli.command
@@ -37,3 +41,16 @@ def clear_config():
     """Reset the user's settings"""
     _CONFIG_FILE_LOCATION.unlink(missing_ok=True)
     print("Your settings have been cleared")
+
+
+@cli.command
+@click.option("--no-confirm", is_flag=True, default=False, help="Don't ask for confirmation")
+def clear_cache(no_confirm: bool):
+    """Reset the lazy-github cache"""
+    cache_directory = LazyGithubContext.config.cache.cache_directory
+    if no_confirm or click.confirm(f"Confirm deletion of everything in {cache_directory}"):
+        if cache_directory.exists():
+            shutil.rmtree(cache_directory)
+        print("Cache cleared")
+    else:
+        print("Canceling cache deletion")

{lazy_github-0.1.7 → lazy_github-0.2}/lazy_github/lib/config.py

@@ -2,9 +2,10 @@ import json
 from contextlib import contextmanager
 from datetime import timedelta
 from pathlib import Path
-from typing import Generator, List, Literal, Optional
+from typing import Any, Generator, Literal, Optional
+from textual.theme import BUILTIN_THEMES, Theme
 
-from pydantic import BaseModel
+from pydantic import BaseModel, field_serializer, field_validator
 
 from lazy_github.lib.constants import CONFIG_FOLDER, IssueOwnerFilter, IssueStateFilter
 
@@ -33,7 +34,7 @@ class IssueSettings(BaseModel):
 
 
 class RepositorySettings(BaseModel):
-    favorites: List[str] = []
+    favorites: list[str] = []
 
 
 class CacheSettings(BaseModel):
@@ -44,13 +45,27 @@ class CacheSettings(BaseModel):
 
 
 class AppearanceSettings(BaseModel):
-    dark_mode: bool = True
+    theme: Theme = BUILTIN_THEMES["textual-dark"]
     # Settings to configure which UI elements to display by default
     show_command_log: bool = True
-    show_actions: bool = True
+    show_workflows: bool = True
     show_issues: bool = True
     show_pull_requests: bool = True
 
+    @field_serializer("theme")
+    @classmethod
+    def serialize_theme(cls, theme: Theme | str) -> str:
+        return theme.name if isinstance(theme, Theme) else theme
+
+    @field_validator("theme", mode="before")
+    @classmethod
+    def validate_theme(cls, theme_name: Any) -> Theme:
+        return BUILTIN_THEMES.get(theme_name, BUILTIN_THEMES["textual-dark"])
+
+
+class CoreConfig(BaseModel):
+    logfile_path: Path = CONFIG_FOLDER / "lazy_github.log"
+
 
 _CONFIG_INSTANCE: Optional["Config"] = None
 
@@ -63,6 +78,7 @@ class Config(BaseModel):
     issues: IssueSettings = IssueSettings()
     cache: CacheSettings = CacheSettings()
     api: ApiConfig = ApiConfig()
+    core: CoreConfig = CoreConfig()
 
     @classmethod
     def load_config(cls) -> "Config":

{lazy_github-0.1.7 → lazy_github-0.2}/lazy_github/lib/git_cli.py

@@ -1,5 +1,5 @@
-import subprocess
 import re
+from subprocess import DEVNULL, SubprocessError, check_output
 
 # Regex designed to match git@github.com:gizmo385/lazy-github.git:
 # ".+:"         Match everything to the first colon
@@ -13,8 +13,8 @@ _GIT_REMOTE_REGEX = re.compile(r".+:([^\/]+)\/([^.]+).git")
 def current_local_repo_full_name(remote: str = "origin") -> str | None:
     """Returns the owner/name associated with the remote of the git repo in the current working directory."""
     try:
-        output = subprocess.check_output(["git", "remote", "get-url", remote]).decode().strip()
-    except subprocess.SubprocessError:
+        output = check_output(["git", "remote", "get-url", remote], stderr=DEVNULL).decode().strip()
+    except SubprocessError:
         return None
 
     if matches := re.match(_GIT_REMOTE_REGEX, output):
@@ -25,6 +25,6 @@ def current_local_repo_full_name(remote: str = "origin") -> str | None:
 def current_local_branch_name() -> str | None:
     """Returns the name of the current branch for the git repo in the current working directory."""
     try:
-        return subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"]).decode().strip()
-    except subprocess.SubprocessError:
+        return check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"], stderr=DEVNULL).decode().strip()
+    except SubprocessError:
         return None

lazy_github-0.2/lazy_github/lib/github/branches.py

@@ -0,0 +1,28 @@
+from lazy_github.lib.constants import DIFF_CONTENT_ACCEPT_TYPE
+from lazy_github.models.github import Branch, Repository
+from lazy_github.lib.context import LazyGithubContext, github_headers
+
+
+async def list_branches(repo: Repository, per_page: int = 30, page: int = 1) -> list[Branch]:
+    """List branches on the specified repo"""
+    query_params = {"page": page, "per_page": per_page}
+    response = await LazyGithubContext.client.get(
+        f"/repos/{repo.owner.login}/{repo.name}/branches",
+        headers=github_headers(),
+        params=query_params,
+    )
+    response.raise_for_status()
+    return [Branch(**branch) for branch in response.json()]
+
+
+async def get_branch(repo: Repository, branch_name: str) -> Branch | None:
+    url = f"/repos/{repo.owner.login}/{repo.name}/branches/{branch_name}"
+    response = await LazyGithubContext.client.get(url, headers=github_headers())
+    return Branch(**response.json())
+
+
+async def compare_branches(repo: Repository, base_branch: Branch, head_branch: Branch) -> str:
+    url = f"/repos/{repo.owner.login}/{repo.name}/compare/{base_branch.name}..{head_branch.name}"
+    response = await LazyGithubContext.client.get(url, headers=github_headers(accept=DIFF_CONTENT_ACCEPT_TYPE))
+    response.raise_for_status()
+    return response.text

{lazy_github-0.1.7 → lazy_github-0.2}/lazy_github/lib/github/issues.py

@@ -4,6 +4,8 @@ from lazy_github.lib.constants import IssueOwnerFilter, IssueStateFilter
 from lazy_github.lib.context import LazyGithubContext, github_headers
 from lazy_github.models.github import Issue, IssueComment, PartialPullRequest, Repository
 
+DEFAULT_PAGE_SIZE = 30
+
 
 class UpdateIssuePayload(TypedDict):
     title: str | None
@@ -11,15 +13,19 @@ class UpdateIssuePayload(TypedDict):
     state: str | None
 
 
-async def list_issues(repo: Repository, state: IssueStateFilter, owner: IssueOwnerFilter) -> list[Issue]:
+async def list_issues(
+    repo: Repository, state: IssueStateFilter, owner: IssueOwnerFilter, page: int = 1, per_page: int = DEFAULT_PAGE_SIZE
+) -> list[Issue]:
     """Fetch issues (included pull requests) from the repo matching the state/owner filters"""
-    query_params = {"state": str(state).lower()}
+    query_params = {"state": str(state).lower(), "page": page, "per_page": per_page}
     if owner == IssueOwnerFilter.MINE:
         user = await LazyGithubContext.client.user()
         query_params["creator"] = user.login
 
     response = await LazyGithubContext.client.get(
-        f"/repos/{repo.owner.login}/{repo.name}/issues", headers=github_headers(), params=query_params
+        f"/repos/{repo.owner.login}/{repo.name}/issues",
+        headers=github_headers(),
+        params=query_params,
     )
     response.raise_for_status()
     result: list[Issue] = []

{lazy_github-0.1.7 → lazy_github-0.2}/lazy_github/lib/github/pull_requests.py

@@ -19,6 +19,24 @@ async def list_for_repo(repo: Repository) -> list[PartialPullRequest]:
     return [i for i in issues if isinstance(i, 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}",
+    }
+    if body:
+        request_body["body"] = body
+    response = await LazyGithubContext.client.post(url, headers=github_headers(), json=request_body)
+    response.raise_for_status()
+    return FullPullRequest(**response.json(), repo=repo)
+
+
 async def get_full_pull_request(partial_pr: PartialPullRequest) -> 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}"

lazy_github-0.2/lazy_github/lib/github/workflows.py

@@ -0,0 +1,41 @@
+from httpx import HTTPError
+from lazy_github.lib.logging import lg
+from lazy_github.lib.context import LazyGithubContext
+from lazy_github.models.github import Repository, Workflow, WorkflowRun
+
+
+async def list_workflows(repository: Repository, page: int = 1, per_page: int = 30) -> list[Workflow]:
+    """Lists available Github action workflows on the specified repo"""
+    query_params = {"page": page, "per_page": per_page}
+    url = f"/repos/{repository.owner.login}/{repository.name}/actions/workflows"
+    try:
+        response = await LazyGithubContext.client.get(url, params=query_params)
+        response.raise_for_status()
+        raw_json = response.json()
+    except HTTPError:
+        lg.exception("Error retrieving actions from the Github API")
+        return []
+    else:
+        if workflows := raw_json.get("workflows"):
+            return [Workflow(**w) for w in workflows]
+        else:
+            return []
+
+
+async def list_workflow_runs(repository: Repository, page: int = 1, per_page: int = 30) -> list[WorkflowRun]:
+    """Lists github workflows runs on the specified repo"""
+    query_params = {"page": page, "per_page": per_page}
+    url = f"/repos/{repository.owner.login}/{repository.name}/actions/runs"
+
+    try:
+        response = await LazyGithubContext.client.get(url, params=query_params)
+        response.raise_for_status()
+        raw_json = response.json()
+    except HTTPError:
+        lg.exception("Error retrieving action runs from the Github API")
+        return []
+    else:
+        if workflows := raw_json.get("workflow_runs"):
+            return [WorkflowRun(**w) for w in workflows]
+        else:
+            return []

lazy_github-0.2/lazy_github/lib/logging.py

@@ -0,0 +1,27 @@
+import logging
+from lazy_github.lib.context import LazyGithubContext
+
+
+# A universal logging format that we can use
+class LazyGithubLogFormatter(logging.Formatter):
+    def __init__(self, include_exceptions: bool = True) -> None:
+        super().__init__("%(levelname)s %(asctime)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+        self.include_exceptions = include_exceptions
+
+    def format(self, record: logging.LogRecord) -> str:
+        if not self.include_exceptions:
+            record.exc_info = None
+            record.exc_text = None
+        return super().format(record)
+
+
+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
+_LOGGERS_TO_MUTE = ["hishel", "httpx", "httpcore", "markdown_it", "asyncio"]
+for other_logger_name in _LOGGERS_TO_MUTE:
+    logging.getLogger(other_logger_name).setLevel(logging.WARNING)

{lazy_github-0.1.7 → lazy_github-0.2}/lazy_github/lib/messages.py

@@ -2,7 +2,7 @@ from functools import cached_property
 
 from textual.message import Message
 
-from lazy_github.models.github import Issue, PartialPullRequest, Repository
+from lazy_github.models.github import FullPullRequest, Issue, IssueComment, PartialPullRequest, Repository
 
 
 class RepoSelected(Message):
@@ -59,3 +59,27 @@ class IssuesAndPullRequestsFetched(Message):
             for issue in self.issues_and_pull_requests
             if isinstance(issue, Issue) and not isinstance(issue, PartialPullRequest)
         ]
+
+
+class PullRequestCreated(Message):
+    def __init__(self, pull_request: FullPullRequest) -> None:
+        super().__init__()
+        self.pull_request = pull_request
+
+
+class IssueCreated(Message):
+    def __init__(self, issue: Issue) -> None:
+        super().__init__()
+        self.issue = issue
+
+
+class NewCommentCreated(Message):
+    def __init__(self, comment: IssueComment) -> None:
+        super().__init__()
+        self.comment = comment
+
+
+class SettingsModalDismissed(Message):
+    def __init__(self, changed: bool) -> None:
+        super().__init__()
+        self.changed = changed

{lazy_github-0.1.7 → lazy_github-0.2}/lazy_github/models/github.py

@@ -22,9 +22,9 @@ class RepositoryPermission(BaseModel):
 class Repository(BaseModel):
     name: str
     full_name: str
-    default_branch: str
+    default_branch: str | None = None
     private: bool
-    archived: bool
+    archived: bool | None = None
     owner: User
     description: str | None = None
     permissions: RepositoryPermission | None = None
@@ -108,6 +108,7 @@ class ReviewState(StrEnum):
     APPROVED = "APPROVED"
     CHANGES_REQUESTED = "CHANGES_REQUESTED"
     COMMENTED = "COMMENTED"
+    DISMISSED = "DISMISSED"
 
 
 class ReviewComment(IssueComment):
@@ -126,3 +127,47 @@ class Review(BaseModel):
     state: ReviewState
     comments: list[ReviewComment] = []
     submitted_at: datetime
+
+
+class Commit(BaseModel):
+    sha: str
+    url: str
+
+
+class Branch(BaseModel):
+    name: str
+    commit: Commit
+    protected: bool
+
+
+class WorkflowState(StrEnum):
+    ACTIVE = "active"
+    DELETED = "deleted"
+    DISABLED_FORK = "disabled_fork"
+    DISABLED_INACTIVITY = "disabled_inactivity"
+    DISABLED_MANUALLY = "disabled_manually "
+
+
+class Workflow(BaseModel):
+    name: str
+    state: WorkflowState
+    path: str
+    created_at: datetime
+    updated_at: datetime
+    url: str
+
+
+class WorkflowRun(BaseModel):
+    name: str
+    display_title: str
+    path: str
+    run_number: int
+    head_branch: str
+    status: str
+    conclusion: str | None = None
+    event: str
+    actor: User
+    triggering_actor: User
+    repository: Repository
+    created_at: datetime
+    updated_at: datetime

lazy_github-0.2/lazy_github/ui/app.py

@@ -0,0 +1,54 @@
+from textual import log
+from textual.app import App
+from textual.theme import Theme
+
+from lazy_github.lib.context import LazyGithubContext
+from lazy_github.lib.github.auth import GithubAuthenticationRequired
+from lazy_github.lib.messages import SettingsModalDismissed
+from lazy_github.ui.screens.auth import AuthenticationModal
+from lazy_github.ui.screens.primary import LazyGithubMainScreen
+
+
+class LazyGithub(App):
+    BINDINGS = [("q", "quit", "Quit"), ("ctrl+p", "command_palette"), ("ctrl+m", "maximize", "Maximize")]
+
+    has_shown_maximize_toast: bool = False
+
+    async def authenticate_with_github(self):
+        try:
+            # We pull the user here to validate auth
+            _ = await LazyGithubContext.client.user()
+            self.push_screen(LazyGithubMainScreen(id="main-screen"))
+        except GithubAuthenticationRequired:
+            log("Triggering auth with github")
+            self.push_screen(AuthenticationModal(id="auth-modal"))
+
+    async def on_ready(self):
+        await self.authenticate_with_github()
+
+    def on_settings_modal_dismissed(self, message: SettingsModalDismissed) -> None:
+        if not message.changed:
+            return
+
+        self.notify("Settings updated")
+        if isinstance(LazyGithubContext.config.appearance.theme, Theme):
+            self.theme = LazyGithubContext.config.appearance.theme.name
+        else:
+            self.theme = LazyGithubContext.config.appearance.theme
+
+        self.query_one("#main-screen", LazyGithubMainScreen).handle_settings_update()
+
+    def on_mount(self) -> None:
+        self.theme = LazyGithubContext.config.appearance.theme.name
+
+    def action_maximize(self) -> None:
+        if self.screen.is_maximized:
+            return
+        if self.screen.focused is not None:
+            # We don't need to repeatedly show this to the user
+            if self.screen.maximize(self.screen.focused) and not self.has_shown_maximize_toast:
+                self.notify("Current view maximized. Press [b]escape[/b] to return.", title="View Maximized")
+                self.has_shown_maximize_toast = True
+
+
+app = LazyGithub()

{lazy_github-0.1.7 → lazy_github-0.2}/lazy_github/ui/screens/new_comment.py

@@ -6,8 +6,9 @@ from textual.screen import ModalScreen
 from textual.widgets import Button, Label, Markdown, Rule, TextArea
 
 from lazy_github.lib.github import issues, pull_requests
+from lazy_github.lib.messages import NewCommentCreated
 from lazy_github.models.github import Issue, IssueComment, Repository, Review, ReviewComment
-from lazy_github.ui.widgets.command_log import log_event
+from lazy_github.lib.logging import lg
 
 CommmentReplyTarget = ReviewComment | Review | IssueComment
 
@@ -83,23 +84,23 @@ class NewCommentContainer(Container):
         body = self.query_one("#new_comment_body", TextArea).text
         try:
             if isinstance(self.reply_to, ReviewComment):
-                await pull_requests.reply_to_review_comment(self.repo, self.issue, self.reply_to, body)
+                new_comment = await pull_requests.reply_to_review_comment(self.repo, self.issue, self.reply_to, body)
             else:
-                await issues.create_comment(self.issue, body)
-        except HTTPStatusError as hse:
+                new_comment = await issues.create_comment(self.issue, body)
+        except HTTPStatusError:
             # TODO: We should handle the error case better here
-            log_event(f"Error while posting comment for issue #{self.issue.number}: {hse}")
+            lg.exception(f"Error while posting comment for issue #{self.issue.number}")
             self.app.pop_screen()
         else:
-            log_event(f"Successfully posted new comment for issue #{self.issue.number}")
-            self.app.pop_screen()
+            lg.info(f"Successfully posted new comment for issue #{self.issue.number}")
+            self.post_message(NewCommentCreated(new_comment))
 
     @on(Button.Pressed, "#cancel_comment")
     def cancel_comment(self, _: Button.Pressed) -> None:
         self.app.pop_screen()
 
 
-class NewCommentModal(ModalScreen):
+class NewCommentModal(ModalScreen[IssueComment | None]):
     DEFAULT_CSS = """
     NewCommentModal {
         border: ascii green;
@@ -134,5 +135,9 @@ class NewCommentModal(ModalScreen):
     def compose(self) -> ComposeResult:
         yield NewCommentContainer(self.repo, self.issue, self.reply_to)
 
+    @on(NewCommentCreated)
+    def on_comment_created(self, message: NewCommentCreated) -> None:
+        self.dismiss(message.comment)
+
     def action_cancel(self) -> None:
-        self.app.pop_screen()
+        self.dismiss(None)

{lazy_github-0.1.7 → lazy_github-0.2}/lazy_github/ui/screens/new_issue.py

@@ -4,8 +4,10 @@ from textual.containers import Container, Horizontal, ScrollableContainer
 from textual.screen import ModalScreen
 from textual.widgets import Button, Input, Label, Rule, TextArea
 
+from lazy_github.lib.context import LazyGithubContext
 from lazy_github.lib.github import issues
-from lazy_github.models.github import Repository
+from lazy_github.lib.messages import IssueCreated
+from lazy_github.models.github import Issue
 
 
 class NewIssueContainer(Container):
@@ -23,11 +25,8 @@ class NewIssueContainer(Container):
     }
     """
 
-    def __init__(self, repo: Repository, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.repo = repo
-
     def compose(self) -> ComposeResult:
+        assert LazyGithubContext.current_repo is not None, "Unexpectedly missing current repo in new PR modal"
         with ScrollableContainer():
             yield Label("[bold]Title[/bold]")
             yield Input(placeholder="Title", id="new_issue_title")
@@ -47,6 +46,8 @@ class NewIssueContainer(Container):
 
     @on(Button.Pressed, "#save_new_issue")
     async def submit_new_issue(self, _: Button) -> None:
+        assert LazyGithubContext.current_repo is not None, "Unexpectedly missing current repo from application context!"
+
         title = self.query_one("#new_issue_title", Input).value
         body = self.query_one("#new_issue_body", TextArea).text
         if not str(title):
@@ -57,12 +58,13 @@ class NewIssueContainer(Container):
             return
 
         self.notify("Creating new issue...")
-        new_issue = await issues.create_issue(self.repo, title, body)
-        self.notify(f"Successfully updated created issue #{new_issue.number}")
-        self.app.pop_screen()
+        new_issue = await issues.create_issue(LazyGithubContext.current_repo, title, body)
+        self.notify(f"Successfully created issue #{new_issue.number}")
+        self.post_message(IssueCreated(new_issue))
 
 
-class NewIssueModal(ModalScreen):
+class NewIssueModal(ModalScreen[Issue | None]):
+    BINDINGS = [("ESC, q", "cancel", "Cancel")]
     DEFAULT_CSS = """
     NewIssueModal {
         align: center middle;
@@ -77,9 +79,12 @@ class NewIssueModal(ModalScreen):
     }
     """
 
-    def __init__(self, repo: Repository, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.repo = repo
-
     def compose(self) -> ComposeResult:
-        yield NewIssueContainer(self.repo)
+        yield NewIssueContainer()
+
+    def action_cancel(self) -> None:
+        self.dismiss()
+
+    @on(IssueCreated)
+    def on_issue_created(self, message: IssueCreated) -> None:
+        self.dismiss(message.issue)