ghnova 0.3.0__py3-none-any.whl

ghnova/cli/user/update.py

@@ -0,0 +1,164 @@
+"""Update command for user CLI."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+
+def update_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,
+    name: Annotated[
+        str | None,
+        typer.Option(
+            "--name",
+            help="The name of the user.",
+        ),
+    ] = None,
+    email: Annotated[
+        str | None,
+        typer.Option(
+            "--email",
+            help="The email of the user.",
+        ),
+    ] = None,
+    blog: Annotated[
+        str | None,
+        typer.Option(
+            "--blog",
+            help="The blog URL of the user.",
+        ),
+    ] = None,
+    twitter_username: Annotated[
+        str | None,
+        typer.Option(
+            "--twitter-username",
+            help="The Twitter username of the user.",
+        ),
+    ] = None,
+    company: Annotated[
+        str | None,
+        typer.Option(
+            "--company",
+            help="The company of the user.",
+        ),
+    ] = None,
+    location: Annotated[
+        str | None,
+        typer.Option(
+            "--location",
+            help="The location of the user.",
+        ),
+    ] = None,
+    hireable: Annotated[
+        bool | None,
+        typer.Option(
+            "--hireable",
+            help="The hireable status of the user.",
+        ),
+    ] = None,
+    bio: Annotated[
+        str | None,
+        typer.Option(
+            "--bio",
+            help="The bio of the user.",
+        ),
+    ] = 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,
+) -> None:
+    """Update the authenticated user's information on 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.
+        name: The name of the user.
+        email: The email of the user.
+        blog: The blog URL of the user.
+        twitter_username: The Twitter username of the user.
+        company: The company of the user.
+        location: The location of the user.
+        hireable: The hireable status of the user.
+        bio: The bio of the user.
+        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.update_user(
+                name=name,
+                email=email,
+                blog=blog,
+                twitter_username=twitter_username,
+                company=company,
+                location=location,
+                hireable=hireable,
+                bio=bio,
+                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 updating user information: %s", e)
+        raise typer.Exit(code=1) from e

ghnova/cli/utils/__init__.py

@@ -0,0 +1,7 @@
+"""Utility functions for the command-line interface."""
+
+from __future__ import annotations
+
+from ghnova.cli.utils.auth import get_auth_params
+
+__all__ = ["get_auth_params"]

ghnova/cli/utils/auth.py

@@ -0,0 +1,67 @@
+"""Utilities for authentication in the CLI."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from ghnova.config.manager import ConfigManager
+
+logger = logging.getLogger("ghnova")
+
+
+def get_auth_params(
+    config_path: Path | str,
+    account_name: str | None,
+    token: str | None,
+    base_url: str | None,
+) -> tuple[str, str]:
+    """Get authentication parameters from CLI context.
+
+    Args:
+        config_path: Path to the configuration file.
+        account_name: Name of the account to use for authentication.
+        token: Token for authentication.
+        base_url: Base URL of the GitHub platform.
+
+    Returns:
+        A tuple containing the token and base URL for authentication.
+
+    """
+    if account_name is not None:
+        if token is not None or base_url is not None:
+            logger.warning(
+                "Both account name and token/base_url provided. The token and base_url from the account '%s' will be used.",
+                account_name,
+            )
+
+        config_manager = ConfigManager(filename=config_path)
+        config_manager.load_config()
+        account_config = config_manager.get_config(name=account_name)
+        token = account_config.token
+        base_url = account_config.base_url
+        return token, base_url
+    if token is None and base_url is None:
+        config_manager = ConfigManager(filename=config_path)
+        config_manager.load_config()
+
+        if config_manager.has_default_account():
+            account_config = config_manager.get_config(name=None)
+            token = account_config.token
+            base_url = account_config.base_url
+            return token, base_url
+        else:
+            raise ValueError(
+                "No default account available for authentication. Please provide an account name or token/base_url."
+            )
+    if token is None or base_url is None:
+        missing_params = []
+        if token is None:
+            missing_params.append("token")
+        if base_url is None:
+            missing_params.append("base_url")
+        raise ValueError(
+            f"Insufficient authentication parameters. Missing: {', '.join(missing_params)}. "
+            f"Please provide both token and base_url, or use an account name."
+        )
+    return token, base_url

ghnova/client/__init__.py

@@ -0,0 +1,8 @@
+"""GitHub client package."""
+
+from __future__ import annotations
+
+from ghnova.client.async_github import AsyncGitHub
+from ghnova.client.github import GitHub
+
+__all__ = ["AsyncGitHub", "GitHub"]

ghnova/client/async_github.py

@@ -0,0 +1,121 @@
+"""Asynchronous GitHub API client implementation."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from aiohttp import ClientResponse, ClientSession, ClientTimeout
+
+from ghnova.client.base import Client
+from ghnova.issue.async_issue import AsyncIssue
+from ghnova.user.async_user import AsyncUser
+
+
+class AsyncGitHub(Client):
+    """Asynchronous GitHub API client."""
+
+    def __init__(self, token: str | None = None, base_url: str = "https://github.com") -> None:
+        """Initialize the asynchronous GitHub client.
+
+        Args:
+            token: The API token for authentication.
+            base_url: The base URL of the GitHub instance.
+
+        """
+        super().__init__(token=token, base_url=base_url)
+        self.session: ClientSession | None = None
+        self.issue = AsyncIssue(client=self)
+        self.user = AsyncUser(client=self)
+
+    def __str__(self) -> str:
+        """Return a string representation of the AsyncGitHub client.
+
+        Returns:
+            str: String representation.
+
+        """
+        return f"<AsyncGitHub base_url={self.base_url}>"
+
+    async def __aenter__(self) -> AsyncGitHub:
+        """Enter the asynchronous context manager.
+
+        Returns:
+            The AsyncGitHub client instance.
+
+        """
+        if self.session is not None and not self.session.closed:
+            raise RuntimeError("AsyncGitHub session already open; do not re-enter context manager.")
+        self.session = ClientSession(headers=self.headers)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit the asynchronous context manager.
+
+        Args:
+            exc_type: The exception type.
+            exc_val: The exception value.
+            exc_tb: The traceback.
+
+        """
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+    def _get_session(self, headers: dict | None = None, **kwargs: Any) -> ClientSession:
+        """Get or create the aiohttp ClientSession.
+
+        Args:
+            headers: Optional headers to include in the session.
+            **kwargs: Additional arguments for ClientSession.
+
+        Returns:
+            The aiohttp ClientSession instance.
+
+        """
+        return ClientSession(headers=headers, **kwargs)
+
+    async def _request(  # noqa: PLR0913
+        self,
+        method: str,
+        endpoint: str,
+        etag: str | None = None,
+        last_modified: str | None = None,
+        headers: dict | None = None,
+        timeout: int = 30,
+        **kwargs: Any,
+    ) -> ClientResponse:
+        """Make an asynchronous HTTP request to the GitHub API.
+
+        Args:
+            method: The HTTP method (GET, POST, etc.).
+            endpoint: The API endpoint.
+            etag: str | None = None,
+            last_modified: str | None = None,
+            headers: Optional headers to include in the request.
+            timeout: Request timeout in seconds.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            The HTTP response.
+
+        """
+        if self.session is None:
+            raise RuntimeError(
+                "AsyncGitHub must be used as an async context manager. "
+                + "Use 'async with AsyncGitHub(...) as client:' to ensure proper resource cleanup."
+            )
+
+        url = self._build_url(endpoint=endpoint)
+        conditional_headers = self._get_conditional_request_headers(etag=etag, last_modified=last_modified)
+        request_headers = {**self.headers, **conditional_headers, **(headers or {})}
+        timeout_obj = ClientTimeout(total=timeout)
+        response = await self.session.request(
+            method=method, url=url, headers=request_headers, timeout=timeout_obj, **kwargs
+        )
+        try:
+            response.raise_for_status()
+        except Exception:
+            response.release()
+            raise
+
+        return response

ghnova/client/base.py

@@ -0,0 +1,78 @@
+"""Base client class for GitHub API interactions."""
+
+from __future__ import annotations
+
+import urllib.parse
+from typing import Any
+
+
+class Client:
+    """Abstract base class for GitHub clients."""
+
+    def __init__(self, token: str | None, base_url: str) -> None:
+        """Construct the base client.
+
+        Args:
+            token: The API token for authentication.
+            base_url: The base URL of the GitHub instance.
+
+        """
+        self.token = token
+        self.base_url = base_url.rstrip("/")
+        self.headers: dict[str, Any] = {}
+        if self.token:
+            self.headers["Authorization"] = f"Bearer {self.token}"
+
+    def __str__(self) -> str:
+        """Return a string representation of the client.
+
+        Returns:
+            str: String representation.
+
+        """
+        return f"<Client base_url={self.base_url}>"
+
+    @property
+    def api_url(self) -> str:
+        """Return the base API URL.
+
+        Returns:
+            str: The base API URL.
+
+        """
+        if urllib.parse.urlparse(self.base_url).netloc == "github.com":
+            return "https://api.github.com"
+        else:
+            return f"{self.base_url}/api/v3"
+
+    def _build_url(self, endpoint: str) -> str:
+        """Construct the full URL for a given endpoint.
+
+        Args:
+            endpoint (str): The API endpoint.
+
+        Returns:
+            str: The full URL.
+
+        """
+        return f"{self.api_url}/{endpoint.lstrip('/')}"
+
+    def _get_conditional_request_headers(
+        self, etag: str | None = None, last_modified: str | None = None
+    ) -> dict[str, str]:
+        """Get headers for conditional requests.
+
+        Args:
+            etag: The ETag value for the resource.
+            last_modified: The Last-Modified timestamp for the resource.
+
+        Returns:
+            A dictionary of headers for the conditional request.
+
+        """
+        headers: dict[str, str] = {}
+        if etag:
+            headers["If-None-Match"] = etag
+        if last_modified:
+            headers["If-Modified-Since"] = last_modified
+        return headers

ghnova/client/github.py

@@ -0,0 +1,107 @@
+"""GitHub API client implementation."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+from requests import Response
+
+from ghnova.client.base import Client
+from ghnova.issue.issue import Issue
+from ghnova.repository.repository import Repository
+from ghnova.user.user import User
+
+
+class GitHub(Client):
+    """Synchronous GitHub API client."""
+
+    def __init__(self, token: str | None = None, base_url: str = "https://github.com") -> None:
+        """Initialize the GitHub client.
+
+        Args:
+            token: The API token for authentication.
+            base_url: The base URL of the GitHub instance.
+
+        """
+        super().__init__(token=token, base_url=base_url)
+        self.session: requests.Session | None = None
+        self.issue = Issue(client=self)
+        self.repository = Repository(client=self)
+        self.user = User(client=self)
+
+    def __str__(self) -> str:
+        """Return a string representation of the GitHub client.
+
+        Returns:
+            str: String representation.
+
+        """
+        return f"<GitHub base_url={self.base_url}>"
+
+    def __enter__(self) -> GitHub:
+        """Enter the context manager.
+
+        Returns:
+            The GitHub client instance.
+
+        """
+        if self.session is not None:
+            raise RuntimeError("GitHub session already open; do not re-enter context manager.")
+        self.session = requests.Session()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit the context manager.
+
+        Args:
+            exc_type: The exception type.
+            exc_val: The exception value.
+            exc_tb: The traceback.
+
+        """
+        if self.session:
+            self.session.close()
+            self.session = None
+
+    def _request(  # noqa: PLR0913
+        self,
+        method: str,
+        endpoint: str,
+        etag: str | None = None,
+        last_modified: str | None = None,
+        headers: dict | None = None,
+        timeout: int = 30,
+        **kwargs: Any,
+    ) -> Response:
+        """Make an HTTP request to the GitHub API.
+
+        Args:
+            method: The HTTP method (GET, POST, etc.).
+            endpoint: The API endpoint.
+            etag: The ETag value for conditional requests.
+            last_modified: The Last-Modified timestamp for conditional requests.
+            headers: Additional headers for the request.
+            timeout: Timeout for the request in seconds.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            The HTTP response.
+
+        """
+        if self.session is None:
+            raise RuntimeError(
+                "GitHub must be used as a context manager. "
+                + "Use 'with GitHub(...) as client:' to ensure proper resource cleanup."
+            )
+        url = self._build_url(endpoint=endpoint)
+        conditional_headers = self._get_conditional_request_headers(etag=etag, last_modified=last_modified)
+        request_headers = {**self.headers, **conditional_headers, **(headers or {})}
+        response = self.session.request(method, url, headers=request_headers, timeout=timeout, **kwargs)
+        try:
+            response.raise_for_status()
+        except Exception:
+            response.close()
+            raise
+
+        return response

ghnova/config/__init__.py

@@ -0,0 +1,8 @@
+"""Initialization of the configuration module for ghnova."""
+
+from __future__ import annotations
+
+from ghnova.config.manager import ConfigManager
+from ghnova.config.model import AccountConfig, Config
+
+__all__ = ["AccountConfig", "Config", "ConfigManager"]