ghnova 0.3.0__py3-none-any.whl

ghnova/cli/main.py

@@ -0,0 +1,117 @@
+# ruff: noqa PL0415
+"""Main entry point for the ghnova CLI application."""
+
+from __future__ import annotations
+
+import enum
+from typing import Annotated
+
+import typer
+
+
+class LoggingLevel(str, enum.Enum):
+    """Logging levels for the CLI."""
+
+    NOTSET = "NOTSET"
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+# Create the main Typer app
+app = typer.Typer(
+    name="ghnova",
+    help="Main CLI for ghnova.",
+    rich_markup_mode="rich",
+)
+
+
+def setup_logging(level: LoggingLevel = LoggingLevel.INFO) -> None:
+    """Set up logging with Rich handler.
+
+    Args:
+        level: Logging level.
+    """
+    import logging
+
+    from rich.console import Console
+    from rich.logging import RichHandler
+
+    logger = logging.getLogger("ghnova")
+
+    logger.setLevel(level.value)
+
+    console = Console(stderr=True)
+
+    # Remove any existing handlers to ensure RichHandler is used
+    for h in logger.handlers[:]:  # Use slice copy to avoid modification during iteration
+        logger.removeHandler(h)
+    # Add the RichHandler
+
+    handler = RichHandler(
+        console=console,
+        rich_tracebacks=True,
+        show_time=True,
+        show_level=True,  # Keep level (e.g., DEBUG, INFO) for clarity
+        markup=True,  # Enable Rich markup in messages for styling
+        level=level.value,  # Ensure handler respects the level
+        omit_repeated_times=False,
+        log_time_format="%H:%M",
+    )
+    handler.setLevel(level.value)
+    logger.addHandler(handler)
+
+    # Prevent propagation to root logger to avoid duplicate output
+    logger.propagate = False
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    config_path: Annotated[
+        str | None,
+        typer.Option(
+            "--config-path",
+            help="Path to the configuration file. If not provided, it uses the path specified by `GHNOVA_CONFIG_PATH`. If the environment variable is not defined, it uses the default location.",
+        ),
+    ] = None,
+    verbose: Annotated[
+        LoggingLevel,
+        typer.Option("--verbose", "-v", help="Set verbosity level."),
+    ] = LoggingLevel.INFO,
+) -> None:
+    """Main entry point for the CLI application.
+
+    Args:
+        ctx: Typer context.
+        config_path: Path to the configuration file.
+        verbose: Verbosity level for logging.
+
+    """
+
+    import os
+
+    config_path = config_path or os.getenv("GHNOVA_CONFIG_PATH")
+
+    ctx.obj = {"config_path": config_path}
+
+    setup_logging(verbose)
+
+
+def register_commands() -> None:
+    """Register CLI commands."""
+
+    from ghnova.cli.config.main import config_app  # noqa: PLC0415
+    from ghnova.cli.issue.main import issue_app  # noqa: PLC0415
+    from ghnova.cli.repository.main import repository_app  # noqa: PLC0415
+    from ghnova.cli.user.main import user_app  # noqa: PLC0415
+
+    app.add_typer(config_app)
+    app.add_typer(issue_app)
+    app.add_typer(repository_app)
+    app.add_typer(user_app)
+
+
+register_commands()

ghnova/cli/repository/__init__.py

@@ -0,0 +1 @@
+"""Command line interface for repository-related operations."""

ghnova/cli/repository/list.py

@@ -0,0 +1,201 @@
+"""List command for repository CLI."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Annotated, Literal
+
+import typer
+
+
+def list_command(  # noqa: PLR0913
+    ctx: typer.Context,
+    owner: Annotated[
+        str | None,
+        typer.Option(
+            "--owner",
+            help="The owner of the repositories.",
+        ),
+    ] = None,
+    organization: Annotated[
+        str | None,
+        typer.Option(
+            "--organization",
+            help="The organization name.",
+        ),
+    ] = None,
+    visibility: Annotated[
+        Literal["all", "public", "private"] | None,
+        typer.Option(
+            "--visibility",
+            help="Filter by visibility: all, public, or private.",
+        ),
+    ] = None,
+    affiliation: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--affiliation",
+            help="Filter by affiliation: owner, collaborator, organization_member.",
+        ),
+    ] = None,
+    repository_type: Annotated[
+        Literal["all", "owner", "public", "private", "member"] | None,
+        typer.Option(
+            "--type",
+            help="Filter by repository type: all, owner, public, private, or member.",
+        ),
+    ] = None,
+    sort: Annotated[
+        Literal["created", "updated", "pushed", "full_name"] | None,
+        typer.Option(
+            "--sort",
+            help="Sort by: created, updated, pushed, or full_name.",
+        ),
+    ] = None,
+    direction: Annotated[
+        Literal["asc", "desc"] | None,
+        typer.Option(
+            "--direction",
+            help="Sort direction: asc or desc.",
+        ),
+    ] = None,
+    per_page: Annotated[
+        int,
+        typer.Option(
+            "--per-page",
+            help="Number of results per page.",
+        ),
+    ] = 30,
+    page: Annotated[
+        int,
+        typer.Option(
+            "--page",
+            help="Page number for pagination.",
+        ),
+    ] = 1,
+    since: Annotated[
+        datetime | None,
+        typer.Option(
+            "--since",
+            help="Only show repositories updated after this time (ISO 8601 format).",
+        ),
+    ] = None,
+    before: Annotated[
+        datetime | None,
+        typer.Option(
+            "--before",
+            help="Only show repositories updated before this time (ISO 8601 format).",
+        ),
+    ] = None,
+    etag: Annotated[
+        str | None,
+        typer.Option(
+            "--etag",
+            help="ETag header value for conditional requests.",
+        ),
+    ] = None,
+    last_modified: Annotated[
+        str | None,
+        typer.Option(
+            "--last-modified",
+            help="Last-Modified header value for conditional requests.",
+        ),
+    ] = None,
+    account_name: Annotated[
+        str | None,
+        typer.Option(
+            "--account-name",
+            help="Name of the account to use for authentication.",
+        ),
+    ] = None,
+    token: Annotated[
+        str | None,
+        typer.Option(
+            "--token",
+            help="Token for authentication. If not provided, the token from the specified account will be used.",
+        ),
+    ] = None,
+    base_url: Annotated[
+        str | None,
+        typer.Option(
+            "--base-url",
+            help="Base URL of the GitHub platform. If not provided, the base URL from the specified account will be used.",
+        ),
+    ] = None,
+) -> None:
+    """List repositories.
+
+    Args:
+        ctx: Typer context.
+        owner: The owner of the repositories.
+        organization: The organization name.
+        visibility: Filter by visibility: all, public, or private.
+        affiliation: Filter by affiliation: owner, collaborator, or organization_member.
+        repository_type: Filter by repository type: all, owner, public, private, or member.
+        sort: Sort by: created, updated, pushed, or full_name.
+        direction: Sort direction: asc or desc.
+        per_page: Number of results per page.
+        page: Page number for pagination.
+        since: Only show repositories updated after this time.
+        before: Only show repositories updated before this time.
+        etag: ETag header value for conditional requests.
+        last_modified: Last-Modified header value for conditional requests.
+        account_name: Name of the account to use for authentication.
+        token: Token for authentication.
+        base_url: Base URL of the GitHub platform.
+
+    """
+    import json  # noqa: PLC0415
+    import logging  # noqa: PLC0415
+    from typing import cast  # noqa: PLC0415
+
+    from ghnova.cli.utils.auth import get_auth_params  # noqa: PLC0415
+    from ghnova.client.github import GitHub  # noqa: PLC0415
+
+    logger = logging.getLogger("ghnova")
+
+    token, base_url = get_auth_params(
+        config_path=ctx.obj["config_path"],
+        account_name=account_name,
+        token=token,
+        base_url=base_url,
+    )
+    affiliation_list = None
+    if affiliation:
+        if not all(a in {"owner", "collaborator", "organization_member"} for a in affiliation):
+            logger.error(
+                "Invalid affiliation value. Must be a comma-separated list of: owner, collaborator, organization_member."
+            )
+            raise typer.Exit(code=1)
+        affiliation_list = cast(list[Literal["owner", "collaborator", "organization_member"]], affiliation)
+
+    try:
+        with GitHub(token=token, base_url=base_url) as client:
+            repository_client = client.repository
+            data, status_code, etag_value, last_modified_value = repository_client.list_repositories(
+                owner=owner,
+                organization=organization,
+                visibility=visibility,
+                affiliation=affiliation_list,
+                repository_type=repository_type,
+                sort=sort,
+                direction=direction,
+                per_page=per_page,
+                page=page,
+                since=since,
+                before=before,
+                etag=etag,
+                last_modified=last_modified,
+            )
+            result = {
+                "data": data,
+                "metadata": {
+                    "status_code": status_code,
+                    "etag": etag_value,
+                    "last_modified": last_modified_value,
+                },
+            }
+            print(json.dumps(result, indent=2, default=str))
+    except Exception as e:
+        logger.exception("Error listing repositories: %s", e)
+        raise typer.Exit(code=1) from e

ghnova/cli/repository/main.py

@@ -0,0 +1,21 @@
+"""Repository CLI commands for ghnova."""
+
+from __future__ import annotations
+
+import typer
+
+repository_app = typer.Typer(
+    name="repository",
+    help="Manage git repositories.",
+    rich_markup_mode="rich",
+)
+
+
+def register_commands() -> None:
+    """Register repository subcommands."""
+    from ghnova.cli.repository.list import list_command  # noqa: PLC0415
+
+    repository_app.command(name="list", help="List repositories.")(list_command)
+
+
+register_commands()

ghnova/cli/user/__init__.py

@@ -0,0 +1 @@
+"""Command line interface for user-related operations."""

ghnova/cli/user/ctx_info.py

@@ -0,0 +1,105 @@
+"""Get contextual information command for user CLI."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+
+def contextual_information_command(  # noqa: PLR0913
+    ctx: typer.Context,
+    account_name: Annotated[
+        str | None,
+        typer.Option(
+            "--account-name",
+            help="Name of the account to use for authentication.",
+        ),
+    ] = None,
+    token: Annotated[
+        str | None,
+        typer.Option(
+            "--token",
+            help="Token for authentication. If not provided, the token from the specified account will be used.",
+        ),
+    ] = None,
+    base_url: Annotated[
+        str | None,
+        typer.Option(
+            "--base-url",
+            help="Base URL of the GitHub platform. If not provided, the base URL from the specified account will be used.",
+        ),
+    ] = None,
+    username: Annotated[
+        str | None,
+        typer.Option(
+            "--username",
+            help="The username of the user to retrieve contextual information for.",
+        ),
+    ] = None,
+    subject_type: Annotated[
+        str | None,
+        typer.Option(
+            "--subject-type",
+            help="The type of subject for the hovercard (e.g., 'organization', 'repository', 'issue', 'pull_request').",
+        ),
+    ] = None,
+    subject_id: Annotated[
+        str | None,
+        typer.Option(
+            "--subject-id",
+            help="The ID of the subject for the hovercard.",
+        ),
+    ] = None,
+) -> None:
+    """Get contextual information about a user on GitHub.
+
+    Args:
+        ctx: Typer context.
+        username: The username of the user to retrieve contextual information for.
+        account_name: Name of the account to use for authentication.
+        token: Token for authentication.
+        base_url: Base URL of the GitHub platform.
+        subject_type: The type of subject for the hovercard.
+        subject_id: The ID of the subject for the hovercard.
+
+    """
+    import json  # noqa: PLC0415
+    import logging  # noqa: PLC0415
+
+    from ghnova.cli.utils.auth import get_auth_params  # noqa: PLC0415
+    from ghnova.client.github import GitHub  # noqa: PLC0415
+
+    logger = logging.getLogger("ghnova")
+
+    if username is None:
+        logger.error("Username must be provided to retrieve contextual information.")
+        raise typer.Exit(code=1)
+
+    token, base_url = get_auth_params(
+        config_path=ctx.obj["config_path"],
+        account_name=account_name,
+        token=token,
+        base_url=base_url,
+    )
+
+    try:
+        with GitHub(token=token, base_url=base_url) as client:
+            user_client = client.user
+            data, status_code, etag_value, last_modified_value = user_client.get_contextual_information(
+                username=username,
+                subject_type=subject_type,
+                subject_id=subject_id,
+            )
+            result = {
+                "data": data,
+                "metadata": {
+                    "status_code": status_code,
+                    "etag": etag_value,
+                    "last_modified": last_modified_value,
+                },
+            }
+            print(json.dumps(result, indent=4))
+    except Exception as e:
+        logger.error("Error retrieving contextual information: %s", e)
+        raise typer.Exit(code=1) from e

ghnova/cli/user/get.py

@@ -0,0 +1,98 @@
+"""Get command for user CLI."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+
+def get_command(  # noqa: PLR0913
+    ctx: typer.Context,
+    account_name: Annotated[
+        str | None,
+        typer.Option(
+            "--account-name",
+            help="Name of the account to use for authentication.",
+        ),
+    ] = None,
+    token: Annotated[
+        str | None,
+        typer.Option(
+            "--token",
+            help="Token for authentication. If not provided, the token from the specified account will be used.",
+        ),
+    ] = None,
+    base_url: Annotated[
+        str | None,
+        typer.Option(
+            "--base-url",
+            help="Base URL of the GitHub platform. If not provided, the base URL from the specified account will be used.",
+        ),
+    ] = None,
+    username: Annotated[
+        str | None,
+        typer.Option(
+            "--username",
+            help="Username of the user to retrieve. If not provided, the authenticated user's information will be retrieved.",
+        ),
+    ] = None,
+    account_id: Annotated[
+        int | None,
+        typer.Option(
+            "--account-id",
+            help="Account ID of the user to retrieve.",
+        ),
+    ] = None,
+    etag: Annotated[
+        str | None,
+        typer.Option("--etag", help="ETag from a previous request for caching purposes."),
+    ] = None,
+    last_modified: Annotated[
+        str | None,
+        typer.Option("--last-modified", help="Last-Modified header from a previous request for caching purposes."),
+    ] = None,
+):
+    """Retrieve user information from GitHub.
+
+    Args:
+        ctx: Typer context.
+        account_name: Name of the account to use for authentication.
+        token: Token for authentication.
+        base_url: Base URL of the GitHub platform.
+        username: Username of the user to retrieve.
+        account_id: Account ID of the user to retrieve.
+        etag: ETag from a previous request for caching purposes.
+        last_modified: Last-Modified header from a previous request for caching purposes.
+
+    """
+    import json  # noqa: PLC0415
+    import logging  # noqa: PLC0415
+
+    from ghnova.cli.utils.auth import get_auth_params  # noqa: PLC0415
+    from ghnova.client.github import GitHub  # noqa: PLC0415
+
+    logger = logging.getLogger("ghnova")
+
+    token, base_url = get_auth_params(
+        config_path=ctx.obj["config_path"], account_name=account_name, token=token, base_url=base_url
+    )
+
+    try:
+        with GitHub(token=token, base_url=base_url) as client:
+            user_client = client.user
+            data, status_code, etag_value, last_modified_value = user_client.get_user(
+                username=username, account_id=account_id, etag=etag, last_modified=last_modified
+            )
+            result = {
+                "data": data,
+                "metadata": {
+                    "status_code": status_code,
+                    "etag": etag_value,
+                    "last_modified": last_modified_value,
+                },
+            }
+            print(json.dumps(result, indent=2, default=str))
+    except Exception as e:
+        logger.error("Error retrieving user information: %s", e)
+        raise typer.Exit(code=1) from e

ghnova/cli/user/list.py

@@ -0,0 +1,78 @@
+"""CLI for listing users."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+
+def list_command(  # noqa: D103, PLR0913
+    ctx: typer.Context,
+    account_name: Annotated[
+        str | None,
+        typer.Option(
+            "--account-name",
+            help="Name of the account to use for authentication.",
+        ),
+    ] = None,
+    token: Annotated[
+        str | None,
+        typer.Option(
+            "--token",
+            help="Token for authentication. If not provided, the token from the specified account will be used.",
+        ),
+    ] = None,
+    base_url: Annotated[
+        str | None,
+        typer.Option(
+            "--base-url",
+            help="Base URL of the GitHub platform. If not provided, the base URL from the specified account will be used.",
+        ),
+    ] = None,
+    since: Annotated[
+        int | None,
+        typer.Option(
+            "--since",
+            help="A user ID. Only return users with an ID greater than this ID.",
+        ),
+    ] = None,
+    per_page: Annotated[int | None, typer.Option("--per-page", help="Number of results per page (max 100).")] = None,
+    etag: Annotated[
+        str | None, typer.Option("--etag", help="ETag from a previous request for caching purposes.")
+    ] = None,
+    last_modified: Annotated[
+        str | None,
+        typer.Option("--last-modified", help="Last-Modified header from a previous request for caching purposes."),
+    ] = None,
+):
+    import json  # noqa: PLC0415
+    import logging  # noqa: PLC0415
+
+    from ghnova.cli.utils.auth import get_auth_params  # noqa: PLC0415
+    from ghnova.client.github import GitHub  # noqa: PLC0415
+
+    logger = logging.getLogger("ghnova")
+
+    token, base_url = get_auth_params(
+        config_path=ctx.obj["config_path"], account_name=account_name, token=token, base_url=base_url
+    )
+
+    try:
+        with GitHub(token=token, base_url=base_url) as client:
+            user_client = client.user
+            data, status_code, etag_value, last_modified_value = user_client.list_users(
+                since=since, per_page=per_page, etag=etag, last_modified=last_modified
+            )
+            result = {
+                "data": data,
+                "metadata": {
+                    "status_code": status_code,
+                    "etag": etag_value,
+                    "last_modified": last_modified_value,
+                },
+            }
+            typer.echo(json.dumps(result, indent=2, default=str))
+    except Exception as e:
+        logger.error("Error listing users: %s", e)
+        raise typer.Exit(code=1) from e

ghnova/cli/user/main.py

@@ -0,0 +1,27 @@
+"""User CLI commands for ghnova."""
+
+from __future__ import annotations
+
+import typer
+
+user_app = typer.Typer(
+    name="user",
+    help="Manage git users.",
+    rich_markup_mode="rich",
+)
+
+
+def register_commands() -> None:
+    """Register user subcommands."""
+    from ghnova.cli.user.ctx_info import contextual_information_command  # noqa: PLC0415
+    from ghnova.cli.user.get import get_command  # noqa: PLC0415
+    from ghnova.cli.user.list import list_command  # noqa: PLC0415
+    from ghnova.cli.user.update import update_command  # noqa: PLC0415
+
+    user_app.command(name="get")(get_command)
+    user_app.command(name="list")(list_command)
+    user_app.command(name="update")(update_command)
+    user_app.command(name="ctx-info")(contextual_information_command)
+
+
+register_commands()