lazy-github 0.0.0__tar.gz

lazy_github-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Christopher Chapline
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lazy_github-0.0.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: lazy-github
+Version: 0.0.0
+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>
+License: MIT License
+        
+        Copyright (c) 2024 Christopher Chapline
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx
+Requires-Dist: hishel
+Requires-Dist: pydantic
+Requires-Dist: textual
+Requires-Dist: textual-dev
+Requires-Dist: click>=8.1.7
+
+![PyPI - Version](https://img.shields.io/pypi/v/lazy-github) ![PyPI - Downloads](https://img.shields.io/pypi/dw/lazy-github)
+
+LazyGithub is a terminal UI client for interacting with [GitHub](https://github.com). It draws heavy inspiration from the
+[lazygit](https://github.com/jesseduffield/lazygit) project and uses [Textual](https://textual.textualize.io/) to drive the terminal UI interactions.
+
+![Example screenshot](https://raw.githubusercontent.com/gizmo385/lazy-github/main/images/lazy-github-conversation-ui.svg)
+
+## How to Use It
+
+You can run the [most recently built version](https://pypi.org/project/lazy-github/) by installing it from PyPI. If you have [uv installed](https://github.com/astral-sh/uv), you can do that easily with `uvx lazy-github`.
+
+When you first start LazyGithub, you will be prompted with a device login code and a link to GitHub
+where you will be able to authenticate the app against your account. This allows the app to act on
+your behalf and is necessary for LazyGithub to function.
+
+Currently, it supports the following:
+
+- Listing the repositories associated with your account 
+- Listing the issues, pull requests, and actions on your repositories
+- Listing the details, diff, and reviews on any of those pull requests
+- Detailed issue and pull request views, including conversation participation
+
+If you wish to run it from a local clone of the repository, you can do so by running the `./start.sh` located in the root of the repo.
+
+## Customization
+
+LazyGithub supports a number of customization options, all of which are stored in `$HOME/.config/lazy-github/config.json`.
+These can be edited manually via changing the config or by opening the settings management UI within LazyGithub. That UI
+can be accessed via the command pallete (`CMD+p`) and then searching for settings.
+
+![Settings screenshot](https://raw.githubusercontent.com/gizmo385/lazy-github/main/images/lazy-github-settings-ui.png)

lazy_github-0.0.0/README.md

@@ -0,0 +1,31 @@
+![PyPI - Version](https://img.shields.io/pypi/v/lazy-github) ![PyPI - Downloads](https://img.shields.io/pypi/dw/lazy-github)
+
+LazyGithub is a terminal UI client for interacting with [GitHub](https://github.com). It draws heavy inspiration from the
+[lazygit](https://github.com/jesseduffield/lazygit) project and uses [Textual](https://textual.textualize.io/) to drive the terminal UI interactions.
+
+![Example screenshot](https://raw.githubusercontent.com/gizmo385/lazy-github/main/images/lazy-github-conversation-ui.svg)
+
+## How to Use It
+
+You can run the [most recently built version](https://pypi.org/project/lazy-github/) by installing it from PyPI. If you have [uv installed](https://github.com/astral-sh/uv), you can do that easily with `uvx lazy-github`.
+
+When you first start LazyGithub, you will be prompted with a device login code and a link to GitHub
+where you will be able to authenticate the app against your account. This allows the app to act on
+your behalf and is necessary for LazyGithub to function.
+
+Currently, it supports the following:
+
+- Listing the repositories associated with your account 
+- Listing the issues, pull requests, and actions on your repositories
+- Listing the details, diff, and reviews on any of those pull requests
+- Detailed issue and pull request views, including conversation participation
+
+If you wish to run it from a local clone of the repository, you can do so by running the `./start.sh` located in the root of the repo.
+
+## Customization
+
+LazyGithub supports a number of customization options, all of which are stored in `$HOME/.config/lazy-github/config.json`.
+These can be edited manually via changing the config or by opening the settings management UI within LazyGithub. That UI
+can be accessed via the command pallete (`CMD+p`) and then searching for settings.
+
+![Settings screenshot](https://raw.githubusercontent.com/gizmo385/lazy-github/main/images/lazy-github-settings-ui.png)

lazy_github-0.0.0/lazy_github/__main__.py

@@ -0,0 +1,4 @@
+from lazy_github.cli import cli
+
+if __name__ == "__main__":
+    cli()

lazy_github-0.0.0/lazy_github/cli.py

@@ -0,0 +1,59 @@
+import shutil
+
+import click
+import rich
+
+from lazy_github.lib.config import _CONFIG_FILE_LOCATION, Config
+from lazy_github.lib.context import LazyGithubContext
+from lazy_github.ui.app import app
+
+_CLI_CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
+
+
+@click.group(invoke_without_command=True, context_settings=_CLI_CONTEXT_SETTINGS)
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    """A Terminal UI for interacting with Github"""
+    if ctx.invoked_subcommand is None:
+        run()
+
+
+@cli.command
+def run():
+    """Run LazyGithub"""
+    app.run()
+
+
+@cli.command
+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()})")
+    rich.print_json(Config.load_config().model_dump_json())
+
+
+@cli.command
+def clear_auth():
+    """Clears out any existing authentication config for LazyGithub, forcing the user to relogin"""
+    from lazy_github.lib.github.auth import _AUTHENTICATION_CACHE_LOCATION
+
+    _AUTHENTICATION_CACHE_LOCATION.unlink(missing_ok=True)
+
+
+@cli.command
+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.0.0/lazy_github/lib/bindings.py

@@ -0,0 +1,72 @@
+from textual.binding import Binding
+
+from lazy_github.lib.utils import classproperty
+
+
+class LazyGithubBindings:
+    # Global App Bindings
+    QUIT_APP = Binding("q", "quit", "Quit", id="app.quit")
+    OPEN_COMMAND_PALLETE = Binding("ctrl+p", "command_palette", "Open command pallete", id="app.command_palette")
+    MAXIMIZE_WIDGET = Binding("ctrl+m", "maximize", "Maximize", id="app.maximize_widget")
+
+    # Triggering creation flows
+    OPEN_ISSUE = Binding("I", "open_issue", "Open new issue", id="issue.new")
+    EDIT_ISSUE = Binding("E", "edit_issue", "Edit issue", id="issue.edit")
+    OPEN_PULL_REQUEST = Binding("P", "open_pull_request", "Open new pull request", 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")
+
+    # Repository actions
+    TOGGLE_FAVORITE_REPO = Binding("ctrl+f", "toggle_favorite_repo", "Toggle favorite", id="repositories.favorite")
+
+    # Common widget bindings
+    SELECT_ENTRY = Binding("enter,space", "select_cursor", "Select table entry", id="common.table.select", show=False)
+    SEARCH_TABLE = Binding("/", "focus_search", "Search", id="common.table.search")
+    TABLE_DOWN = Binding("j", "cursor_down", "Table cursor down", show=False, id="common.table.cursor_down")
+    TABLE_PAGE_DOWN = Binding("J", "page_down", "Table page down", show=False, id="common.table.page_down")
+    TABLE_CURSOR_UP = Binding("k", "cursor_up", "Table cursor up", show=False, id="common.table.cursor_up")
+    TABLE_PAGE_UP = Binding("K", "page_up", "Table page up", show=False, id="common.table.page_up")
+    TABLE_SCROLL_RIGHT = Binding("l", "scroll_right", "Table scroll right", show=False, id="common.table.scroll_right")
+    TABLE_PAGE_RIGHT = Binding("L", "page_right", "Table page right", show=False, id="common.table.page_right")
+    TABLE_SCROLL_LEFT = Binding("h", "scroll_left", "Table scroll left", show=False, id="common.table.scroll_left")
+    TABLE_PAGE_LEFT = Binding("H", "page_left", "Table page left", show=False, id="common.table.page_left")
+    TABLE_SCROLL_TOP = Binding("g", "scroll_top", "Table scroll to top", show=False, id="common.table.scroll_top")
+    TABLE_SCROLL_BOTTOM = Binding(
+        "G", "scroll_bottom", "Table scroll to bottom", show=False, id="common.table.scroll_bottom"
+    )
+    TABLE_PAGE_LEFT = Binding("^", "page_left", "Table page left", show=False, id="common.table.page_left")
+    TABLE_PAGE_RIGHT = Binding("$", "page_right", "Table page right", show=False, id="common.table.page_right")
+
+    # Dialog bindings
+    SUBMIT_DIALOG = Binding("shift+enter", "submit", "Submit", id="modal.submit")
+    CANCEL_DIALOG = Binding("q, ESC", "cancel", "Cancel", id="modal.cancel")
+    SEARCH_DIALOG = Binding("/", "search", "Search", id="modal.search")
+
+    # Focusing different UI elements
+    FOCUS_REPOSITORY_TABLE = Binding(
+        "1", "focus_section('#repos_table')", "Focus repos table", show=False, id="main.repos.focus"
+    )
+    FOCUS_PULL_REQUEST_TABLE = Binding(
+        "2", "focus_section('#pull_requests_table')", "Focus PRs table", show=False, id="main.pull_requests.focus"
+    )
+    FOCUS_ISSUE_TABLE = Binding(
+        "3", "focus_section('#issues_table')", "Focus issues table", show=False, id="main.issues.focus"
+    )
+    FOCUS_WORKFLOW_TABS = Binding(
+        "4", "focus_workflow_tabs", "Focus workflows table", show=False, id="main.workflows.focus"
+    )
+    FOCUS_DETAIL_TABS = Binding("5", "focus_tabs", "Focus details tabs", show=False, id="main.details.focus")
+    FOCUS_COMMAND_LOG = Binding(
+        "6", "focus_section('LazyGithubCommandLog')", "Focus command log", show=False, id="main.command_log.focus"
+    )
+
+    @classproperty
+    def all(cls) -> list[Binding]:
+        """Returns all bindings which can be rebound"""
+        return [v for v in cls.__dict__.values() if isinstance(v, Binding) if v.id]
+
+    @classproperty
+    def all_by_id(cls) -> dict[str, Binding]:
+        """Returns a dictionary of all bindings which can be rebound, with the key being their ID"""
+        return {v.id: v for v in cls.__dict__.values() if isinstance(v, Binding) and v.id}

lazy_github-0.0.0/lazy_github/lib/config.py

@@ -0,0 +1,129 @@
+import json
+from contextlib import contextmanager
+from datetime import timedelta
+from pathlib import Path
+from typing import Any, Generator, Literal, Optional
+
+from pydantic import BaseModel, field_serializer, field_validator
+from textual.theme import BUILTIN_THEMES, Theme
+
+from lazy_github.lib.constants import CONFIG_FOLDER, IssueOwnerFilter, IssueStateFilter
+
+_CONFIG_FILE_LOCATION = CONFIG_FOLDER / "config.json"
+
+ISSUE_STATE_FILTER = Literal["all"] | Literal["open"] | Literal["closed"]
+ISSUE_OWNER_FILTER = Literal["mine"] | Literal["all"]
+
+
+class AppearanceSettings(BaseModel):
+    """Settings focused on altering the appearance of LazyGithub, including hiding or showing different sections."""
+
+    theme: Theme = BUILTIN_THEMES["textual-dark"]
+    # Settings to configure which UI elements to display by default
+    show_command_log: 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 NotificationSettings(BaseModel):
+    """Controls the settings for the optional notification feature, which relies on the standard GitHub CLI."""
+
+    enabled: bool = False
+    show_all_notifications: bool = True
+
+
+class BindingsSettings(BaseModel):
+    """Custom keybinding overrides for LazyGithub. When rebinding, pressing ESCAPE will reset to the default binding."""
+
+    overrides: dict[str, str] = {}
+
+
+class RepositorySettings(BaseModel):
+    """Repository-specific settings"""
+
+    favorites: list[str] = []
+
+
+class PullRequestSettings(BaseModel):
+    """Changes how pull requests are retrieved from the Github API"""
+
+    state_filter: IssueStateFilter = IssueStateFilter.ALL
+    owner_filter: IssueOwnerFilter = IssueOwnerFilter.ALL
+
+
+class IssueSettings(BaseModel):
+    """Changes how issues are retrieved from the Github API"""
+
+    state_filter: IssueStateFilter = IssueStateFilter.ALL
+    owner_filter: IssueOwnerFilter = IssueOwnerFilter.ALL
+
+
+class CacheSettings(BaseModel):
+    """Settings that control how long data will be cached from the GitHub API"""
+
+    cache_directory: Path = CONFIG_FOLDER / ".cache"
+    default_ttl: int = int(timedelta(minutes=10).total_seconds())
+    list_repos_ttl: int = int(timedelta(days=1).total_seconds())
+    list_issues_ttl: int = int(timedelta(hours=1).total_seconds())
+
+
+class CoreConfig(BaseModel):
+    logfile_path: Path = CONFIG_FOLDER / "lazy_github.log"
+
+
+class ApiConfig(BaseModel):
+    """Controlling how the GitHub API is accessed in LazyGithub"""
+
+    base_url: str = "https://api.github.com"
+
+
+_CONFIG_INSTANCE: Optional["Config"] = None
+
+
+class Config(BaseModel):
+    appearance: AppearanceSettings = AppearanceSettings()
+    notifications: NotificationSettings = NotificationSettings()
+    bindings: BindingsSettings = BindingsSettings()
+    repositories: RepositorySettings = RepositorySettings()
+    pull_requests: PullRequestSettings = PullRequestSettings()
+    issues: IssueSettings = IssueSettings()
+    cache: CacheSettings = CacheSettings()
+    core: CoreConfig = CoreConfig()
+    api: ApiConfig = ApiConfig()
+
+    @classmethod
+    def load_config(cls) -> "Config":
+        global _CONFIG_INSTANCE
+        if _CONFIG_INSTANCE is None:
+            if _CONFIG_FILE_LOCATION.exists():
+                _CONFIG_INSTANCE = cls(**json.loads(_CONFIG_FILE_LOCATION.read_text()))
+            else:
+                _CONFIG_INSTANCE = cls()
+        return _CONFIG_INSTANCE
+
+    def save(self) -> None:
+        CONFIG_FOLDER.mkdir(parents=True, exist_ok=True)
+        _CONFIG_FILE_LOCATION.write_text(self.model_dump_json(indent=4))
+
+    @classmethod
+    @contextmanager
+    def to_edit(cls) -> Generator["Config", None, None]:
+        current_config = cls.load_config()
+        yield current_config
+        current_config.save()
+
+
+if __name__ == "__main__":
+    print(f"Config file location: {_CONFIG_FILE_LOCATION} (exists => {_CONFIG_FILE_LOCATION.exists()})")
+    print(Config.load_config().model_dump_json(indent=4))

lazy_github-0.0.0/lazy_github/lib/constants.py

@@ -0,0 +1,41 @@
+from enum import StrEnum
+from pathlib import Path
+
+# Content types
+DIFF_CONTENT_ACCEPT_TYPE = "application/vnd.github.diff"
+JSON_CONTENT_ACCEPT_TYPE = "application/vnd.github+json"
+
+# App access information
+LAZY_GITHUB_CLIENT_ID = "Iv23limdG8Bl3Cu5FOcT"
+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 = "☆"
+IS_PRIVATE = "✔"
+IS_PUBLIC = "✘"
+
+NOTIFICATION_REFRESH_INTERVAL = 60
+
+CONFIG_FOLDER = Path.home() / ".config/lazy-github"
+
+
+def favorite_string(favorite: bool) -> str:
+    """Helper function to return the right string to indicate if something is favorited"""
+    return IS_FAVORITED if favorite else IS_NOT_FAVORITED
+
+
+def private_string(private: bool) -> str:
+    """Helper function to return the right string to indicate if something is private"""
+    return IS_PRIVATE if private else IS_PUBLIC
+
+
+class IssueStateFilter(StrEnum):
+    ALL = "all"
+    OPEN = "open"
+    CLOSED = "closed"
+
+
+class IssueOwnerFilter(StrEnum):
+    MINE = "mine"
+    ALL = "all"

lazy_github-0.0.0/lazy_github/lib/context.py

@@ -0,0 +1,46 @@
+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.github.auth import token
+from lazy_github.lib.github.client import GithubClient
+from lazy_github.lib.utils import classproperty
+from lazy_github.models.github import Repository
+
+
+class LazyGithubContext:
+    """Globally accessible wrapper class that centralizes access to the configuration and the Github API client"""
+
+    # Attributes exposed via properties
+    _config: Config | None = None
+    _client: GithubClient | None = None
+    _current_directory_repo: str | None = None
+
+    # Directly assigned attributes
+    current_repo: Repository | None = None
+
+    @classproperty
+    def config(cls) -> Config:
+        if cls._config is None:
+            cls._config = Config.load_config()
+        return cls._config
+
+    @classproperty
+    def client(cls) -> GithubClient:
+        # Ideally this is would just be a none check but that doesn't properly type check for some reason
+        if not isinstance(cls._client, GithubClient):
+            cls._client = GithubClient(cls.config, token())
+        return cls._client
+
+    @classproperty
+    def current_directory_repo(cls) -> str | None:
+        """The owner/name of the repo associated with the current working directory (if one exists)"""
+        if not cls._current_directory_repo:
+            cls._current_directory_repo = current_local_repo_full_name()
+        return cls._current_directory_repo
+
+
+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"""
+    return LazyGithubContext.client.github_headers(accept, cache_duration)

lazy_github-0.0.0/lazy_github/lib/git_cli.py

@@ -0,0 +1,30 @@
+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
+# "([^\/]+)"    Match everything until the forward slash, which should be owner
+# "\/"          Match the forward slash
+# "([^.]+)"     Match everything until the period, which should be the repo name
+# ".git"        Match the .git suffix
+_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 = check_output(["git", "remote", "get-url", remote], stderr=DEVNULL).decode().strip()
+    except SubprocessError:
+        return None
+
+    if matches := re.match(_GIT_REMOTE_REGEX, output):
+        owner, name = matches.groups()
+        return f"{owner}/{name}"
+
+
+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 check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"], stderr=DEVNULL).decode().strip()
+    except SubprocessError:
+        return None

lazy_github-0.0.0/lazy_github/lib/github/auth.py

@@ -0,0 +1,100 @@
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+import httpx
+
+from lazy_github.lib.constants import CONFIG_FOLDER, DEVICE_CODE_GRANT_TYPE, LAZY_GITHUB_CLIENT_ID
+
+# Auth and client globals
+_AUTHENTICATION_CACHE_LOCATION = CONFIG_FOLDER / "auth.text"
+_AUTH_TOKEN: Optional[str] = None
+
+
+@dataclass
+class DeviceCodeResponse:
+    device_code: str
+    verification_uri: str
+    user_code: str
+    polling_interval: int
+    expires_at: int
+
+
+@dataclass
+class AccessTokenResponse:
+    token: Optional[str]
+    error: Optional[str]
+
+
+class GithubAuthenticationRequired(Exception):
+    pass
+
+
+async def get_device_code() -> DeviceCodeResponse:
+    """
+    Authenticates this device with the Github API. This will require the user to go enter the provided device code on
+    the Github UI to authenticate the LazyGithub app.
+    """
+    async with httpx.AsyncClient() as client:
+        response = await client.post(
+            "https://github.com/login/device/code",
+            data={"client_id": LAZY_GITHUB_CLIENT_ID},
+            headers={"Accept": "application/json"},
+        )
+
+    response.raise_for_status()
+    body = response.json()
+    expires_at = time.time() + body["expires_in"]
+    return DeviceCodeResponse(
+        body["device_code"],
+        body["verification_uri"],
+        body["user_code"],
+        body["interval"],
+        expires_at,
+    )
+
+
+async def get_access_token(device_code: DeviceCodeResponse) -> AccessTokenResponse:
+    """Given a device code, retrieves the oauth access token that can be used to send requests to the GIthub API"""
+    async with httpx.AsyncClient() as client:
+        # TODO: This should specify an accept
+        access_token_res = await client.post(
+            "https://github.com/login/oauth/access_token",
+            data={
+                "client_id": LAZY_GITHUB_CLIENT_ID,
+                "grant_type": DEVICE_CODE_GRANT_TYPE,
+                "device_code": device_code.device_code,
+            },
+        )
+    access_token_res.raise_for_status()
+    pairs = access_token_res.text.split("&")
+    access_token_data = dict(pair.split("=") for pair in pairs)
+    return AccessTokenResponse(
+        access_token_data.get("access_token"),
+        access_token_data.get("error"),
+    )
+
+
+def save_access_token(access_token: AccessTokenResponse) -> None:
+    """Writes the returned access token to the config location"""
+    if not access_token.token:
+        raise ValueError("Invalid access token response! Cannot save")
+
+    # Create the parent directories for our cache if it's present
+    _AUTHENTICATION_CACHE_LOCATION.parent.mkdir(parents=True, exist_ok=True)
+    _AUTHENTICATION_CACHE_LOCATION.write_text(access_token.token)
+
+
+def token() -> str:
+    """
+    Helper function which loads the token from the file on disk. If the file does not exist, it raises a
+    GithubAuthenticationRequired exception that the caller should handle by triggering the auth flow
+    """
+    global _AUTH_TOKEN
+    if _AUTH_TOKEN is not None:
+        return _AUTH_TOKEN
+
+    if not _AUTHENTICATION_CACHE_LOCATION.exists():
+        raise GithubAuthenticationRequired()
+    _AUTH_TOKEN = _AUTHENTICATION_CACHE_LOCATION.read_text().strip()
+    return _AUTH_TOKEN

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

@@ -0,0 +1,28 @@
+from lazy_github.lib.constants import DIFF_CONTENT_ACCEPT_TYPE
+from lazy_github.lib.context import LazyGithubContext, github_headers
+from lazy_github.models.github import Branch, Repository
+
+
+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