arthexis 0.1.13__py3-none-any.whl → 0.1.14__py3-none-any.whl

core/github_helper.py

@@ -1,25 +1,188 @@
-"""Helpers for reporting exceptions to GitHub."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from celery import shared_task
-
-
-logger = logging.getLogger(__name__)
-
-
-@shared_task
-def report_exception_to_github(payload: dict[str, Any]) -> None:
-    """Send exception context to the GitHub issue helper.
-
-    The task is intentionally light-weight in this repository. Deployments can
-    replace it with an implementation that forwards ``payload`` to the
-    automation responsible for creating GitHub issues.
-    """
-
-    logger.info(
-        "Queued GitHub issue report for %s", payload.get("fingerprint", "<unknown>")
-    )
+"""Helpers for reporting exceptions to GitHub and managing repositories."""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+from celery import shared_task
+import requests
+
+
+if TYPE_CHECKING:  # pragma: no cover - typing only
+    from .models import Package
+
+
+logger = logging.getLogger(__name__)
+
+
+GITHUB_API_ROOT = "https://api.github.com"
+REQUEST_TIMEOUT = 10
+
+
+class GitHubRepositoryError(RuntimeError):
+    """Raised when a GitHub repository operation fails."""
+
+
+
+@shared_task
+def report_exception_to_github(payload: dict[str, Any]) -> None:
+    """Send exception context to the GitHub issue helper.
+
+    The task is intentionally light-weight in this repository. Deployments can
+    replace it with an implementation that forwards ``payload`` to the
+    automation responsible for creating GitHub issues.
+    """
+
+    logger.info(
+        "Queued GitHub issue report for %s", payload.get("fingerprint", "<unknown>")
+    )
+
+
+def _resolve_github_token(package: Package | None) -> str:
+    """Return the GitHub token for ``package``.
+
+    Preference is given to the release manager associated with the package.
+    When unavailable, fall back to the ``GITHUB_TOKEN`` environment variable.
+    """
+
+    if package:
+        manager = getattr(package, "release_manager", None)
+        if manager:
+            token = getattr(manager, "github_token", "")
+            if token:
+                cleaned = str(token).strip()
+                if cleaned:
+                    return cleaned
+
+    token = os.environ.get("GITHUB_TOKEN", "")
+    cleaned_env = token.strip() if isinstance(token, str) else str(token).strip()
+    if not cleaned_env:
+        raise GitHubRepositoryError("GitHub token is not configured")
+    return cleaned_env
+
+
+def _build_headers(token: str) -> Mapping[str, str]:
+    return {
+        "Accept": "application/vnd.github+json",
+        "Authorization": f"token {token}",
+        "User-Agent": "arthexis-admin",
+    }
+
+
+def _build_payload(repo: str, *, private: bool, description: str | None) -> dict[str, Any]:
+    payload: dict[str, Any] = {"name": repo, "private": private}
+    if description:
+        payload["description"] = description
+    return payload
+
+
+def _extract_error_message(response: requests.Response) -> str:
+    try:
+        data = response.json()
+    except ValueError:
+        data = {}
+
+    message = data.get("message") or response.text or "GitHub repository request failed"
+    errors = data.get("errors")
+    details: list[str] = []
+    if isinstance(errors, list):
+        for entry in errors:
+            if isinstance(entry, str):
+                details.append(entry)
+            elif isinstance(entry, Mapping):
+                text = entry.get("message") or entry.get("code")
+                if text:
+                    details.append(str(text))
+
+    if details:
+        message = f"{message} ({'; '.join(details)})"
+
+    return message
+
+
+def _safe_json(response: requests.Response) -> dict[str, Any]:
+    try:
+        data = response.json()
+    except ValueError:
+        data = {}
+    return data
+
+
+def create_repository_for_package(
+    package: Package,
+    *,
+    owner: str,
+    repo: str,
+    private: bool = False,
+    description: str | None = None,
+) -> str:
+    """Create a GitHub repository and return its canonical URL.
+
+    The helper attempts to create the repository under ``owner`` when provided.
+    If the authenticated token lacks access to the organization, the helper
+    falls back to creating the repository for the authenticated user. On
+    success, the GitHub HTML URL for the repository is returned.
+    """
+
+    token = _resolve_github_token(package)
+    headers = _build_headers(token)
+    payload = _build_payload(repo, private=private, description=description)
+
+    endpoints: list[str] = []
+    owner = owner.strip()
+    if owner:
+        endpoints.append(f"{GITHUB_API_ROOT}/orgs/{owner}/repos")
+    endpoints.append(f"{GITHUB_API_ROOT}/user/repos")
+
+    last_error: str | None = None
+
+    for index, endpoint in enumerate(endpoints):
+        try:
+            response = requests.post(
+                endpoint,
+                json=payload,
+                headers=headers,
+                timeout=REQUEST_TIMEOUT,
+            )
+        except requests.RequestException as exc:  # pragma: no cover - network failure
+            logger.exception(
+                "GitHub repository creation request failed for %s/%s", owner, repo
+            )
+            raise GitHubRepositoryError(str(exc)) from exc
+
+        if 200 <= response.status_code < 300:
+            data = _safe_json(response)
+            html_url = data.get("html_url")
+            if html_url:
+                return html_url
+
+            resolved_owner = (
+                data.get("owner", {}).get("login")
+                if isinstance(data.get("owner"), Mapping)
+                else owner
+            )
+            resolved_owner = (resolved_owner or owner).strip("/")
+            return f"https://github.com/{resolved_owner}/{repo}"
+
+        message = _extract_error_message(response)
+        logger.error(
+            "GitHub repository creation failed for %s/%s (%s): %s",
+            owner or "<user>",
+            repo,
+            response.status_code,
+            message,
+        )
+        last_error = message
+
+        # If we're attempting to create within an organization and receive a
+        # not found or forbidden error, fall back to creating for the
+        # authenticated user.
+        if index == 0 and owner and response.status_code in {403, 404}:
+            continue
+
+        break
+
+    raise GitHubRepositoryError(last_error or "GitHub repository creation failed")

core/github_issues.py

@@ -1,172 +1,178 @@
-from __future__ import annotations
-
-import hashlib
-import logging
-import os
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Iterable, Mapping
-
-import requests
-
-from .models import Package, PackageRelease
-from .release import DEFAULT_PACKAGE
-
-
-logger = logging.getLogger(__name__)
-
-BASE_DIR = Path(__file__).resolve().parent.parent
-LOCK_DIR = BASE_DIR / "locks" / "github-issues"
-LOCK_TTL = timedelta(hours=1)
-REQUEST_TIMEOUT = 10
-
-
-def resolve_repository() -> tuple[str, str]:
-    """Return the ``(owner, repo)`` tuple for the active package."""
-
-    package = Package.objects.filter(is_active=True).first()
-    repository_url = (
-        package.repository_url
-        if package and package.repository_url
-        else DEFAULT_PACKAGE.repository_url
-    )
-
-    owner: str
-    repo: str
-
-    if repository_url.startswith("git@"):
-        _, _, remainder = repository_url.partition(":")
-        path = remainder
-    else:
-        from urllib.parse import urlparse
-
-        parsed = urlparse(repository_url)
-        path = parsed.path
-
-    path = path.strip("/")
-    if path.endswith(".git"):
-        path = path[:-4]
-
-    segments = [segment for segment in path.split("/") if segment]
-    if len(segments) < 2:
-        raise ValueError(f"Invalid repository URL: {repository_url!r}")
-
-    owner, repo = segments[-2], segments[-1]
-    return owner, repo
-
-
-def get_github_token() -> str:
-    """Return the configured GitHub token.
-
-    Preference is given to the latest :class:`~core.models.PackageRelease`.
-    When unavailable, fall back to the ``GITHUB_TOKEN`` environment variable.
-    """
-
-    latest_release = PackageRelease.latest()
-    if latest_release:
-        token = latest_release.get_github_token()
-        if token:
-            return token
-
-    try:
-        return os.environ["GITHUB_TOKEN"]
-    except KeyError as exc:  # pragma: no cover - defensive guard
-        raise RuntimeError("GitHub token is not configured") from exc
-
-
-def _ensure_lock_dir() -> None:
-    LOCK_DIR.mkdir(parents=True, exist_ok=True)
-
-
-def _fingerprint_digest(fingerprint: str) -> str:
-    return hashlib.sha256(str(fingerprint).encode("utf-8")).hexdigest()
-
-
-def _fingerprint_path(fingerprint: str) -> Path:
-    return LOCK_DIR / _fingerprint_digest(fingerprint)
-
-
-def _has_recent_marker(lock_path: Path) -> bool:
-    if not lock_path.exists():
-        return False
-
-    marker_age = datetime.utcnow() - datetime.utcfromtimestamp(
-        lock_path.stat().st_mtime
-    )
-    return marker_age < LOCK_TTL
-
-
-def build_issue_payload(
-    title: str,
-    body: str,
-    labels: Iterable[str] | None = None,
-    fingerprint: str | None = None,
-) -> Mapping[str, object] | None:
-    """Return an API payload for GitHub issues.
-
-    When ``fingerprint`` is provided, duplicate submissions within ``LOCK_TTL``
-    are ignored by returning ``None``. A marker is kept on disk to prevent
-    repeated reports during the cooldown window.
-    """
-
-    payload: dict[str, object] = {"title": title, "body": body}
-
-    if labels:
-        deduped = list(dict.fromkeys(labels))
-        if deduped:
-            payload["labels"] = deduped
-
-    if fingerprint:
-        _ensure_lock_dir()
-        lock_path = _fingerprint_path(fingerprint)
-        if _has_recent_marker(lock_path):
-            logger.info("Skipping GitHub issue for active fingerprint %s", fingerprint)
-            return None
-
-        lock_path.write_text(datetime.utcnow().isoformat(), encoding="utf-8")
-        digest = _fingerprint_digest(fingerprint)
-        payload["body"] = f"{body}\n\n<!-- fingerprint:{digest} -->"
-
-    return payload
-
-
-def create_issue(
-    title: str,
-    body: str,
-    labels: Iterable[str] | None = None,
-    fingerprint: str | None = None,
-) -> requests.Response | None:
-    """Create a GitHub issue using the configured repository and token."""
-
-    payload = build_issue_payload(title, body, labels=labels, fingerprint=fingerprint)
-    if payload is None:
-        return None
-
-    owner, repo = resolve_repository()
-    token = get_github_token()
-
-    headers = {
-        "Accept": "application/vnd.github+json",
-        "Authorization": f"token {token}",
-        "User-Agent": "arthexis-runtime-reporter",
-    }
-    url = f"https://api.github.com/repos/{owner}/{repo}/issues"
-
-    response = requests.post(
-        url, json=payload, headers=headers, timeout=REQUEST_TIMEOUT
-    )
-    if not (200 <= response.status_code < 300):
-        logger.error(
-            "GitHub issue creation failed with status %s: %s",
-            response.status_code,
-            response.text,
-        )
-        response.raise_for_status()
-
-    logger.info(
-        "GitHub issue created for %s/%s with status %s",
-        owner,
-        repo,
-        response.status_code,
-    )
-    return response
+from __future__ import annotations
+
+import hashlib
+import logging
+import os
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Iterable, Mapping
+
+import requests
+
+from .models import Package, PackageRelease
+from .release import DEFAULT_PACKAGE
+
+
+logger = logging.getLogger(__name__)
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+LOCK_DIR = BASE_DIR / "locks" / "github-issues"
+LOCK_TTL = timedelta(hours=1)
+REQUEST_TIMEOUT = 10
+
+
+def resolve_repository() -> tuple[str, str]:
+    """Return the ``(owner, repo)`` tuple for the active package."""
+
+    package = Package.objects.filter(is_active=True).first()
+
+    repository_url: str
+    if package is not None:
+        raw_url = getattr(package, "repository_url", "")
+        if raw_url is None:
+            cleaned_url = ""
+        else:
+            cleaned_url = str(raw_url).strip()
+        repository_url = cleaned_url or DEFAULT_PACKAGE.repository_url
+    else:
+        repository_url = DEFAULT_PACKAGE.repository_url
+
+    owner: str
+    repo: str
+
+    if repository_url.startswith("git@"):
+        _, _, remainder = repository_url.partition(":")
+        path = remainder
+    else:
+        from urllib.parse import urlparse
+
+        parsed = urlparse(repository_url)
+        path = parsed.path
+
+    path = path.strip("/")
+    if path.endswith(".git"):
+        path = path[:-4]
+
+    segments = [segment for segment in path.split("/") if segment]
+    if len(segments) < 2:
+        raise ValueError(f"Invalid repository URL: {repository_url!r}")
+
+    owner, repo = segments[-2], segments[-1]
+    return owner, repo
+
+
+def get_github_token() -> str:
+    """Return the configured GitHub token.
+
+    Preference is given to the latest :class:`~core.models.PackageRelease`.
+    When unavailable, fall back to the ``GITHUB_TOKEN`` environment variable.
+    """
+
+    latest_release = PackageRelease.latest()
+    if latest_release:
+        token = latest_release.get_github_token()
+        if token:
+            return token
+
+    try:
+        return os.environ["GITHUB_TOKEN"]
+    except KeyError as exc:  # pragma: no cover - defensive guard
+        raise RuntimeError("GitHub token is not configured") from exc
+
+
+def _ensure_lock_dir() -> None:
+    LOCK_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _fingerprint_digest(fingerprint: str) -> str:
+    return hashlib.sha256(str(fingerprint).encode("utf-8")).hexdigest()
+
+
+def _fingerprint_path(fingerprint: str) -> Path:
+    return LOCK_DIR / _fingerprint_digest(fingerprint)
+
+
+def _has_recent_marker(lock_path: Path) -> bool:
+    if not lock_path.exists():
+        return False
+
+    marker_age = datetime.utcnow() - datetime.utcfromtimestamp(
+        lock_path.stat().st_mtime
+    )
+    return marker_age < LOCK_TTL
+
+
+def build_issue_payload(
+    title: str,
+    body: str,
+    labels: Iterable[str] | None = None,
+    fingerprint: str | None = None,
+) -> Mapping[str, object] | None:
+    """Return an API payload for GitHub issues.
+
+    When ``fingerprint`` is provided, duplicate submissions within ``LOCK_TTL``
+    are ignored by returning ``None``. A marker is kept on disk to prevent
+    repeated reports during the cooldown window.
+    """
+
+    payload: dict[str, object] = {"title": title, "body": body}
+
+    if labels:
+        deduped = list(dict.fromkeys(labels))
+        if deduped:
+            payload["labels"] = deduped
+
+    if fingerprint:
+        _ensure_lock_dir()
+        lock_path = _fingerprint_path(fingerprint)
+        if _has_recent_marker(lock_path):
+            logger.info("Skipping GitHub issue for active fingerprint %s", fingerprint)
+            return None
+
+        lock_path.write_text(datetime.utcnow().isoformat(), encoding="utf-8")
+        digest = _fingerprint_digest(fingerprint)
+        payload["body"] = f"{body}\n\n<!-- fingerprint:{digest} -->"
+
+    return payload
+
+
+def create_issue(
+    title: str,
+    body: str,
+    labels: Iterable[str] | None = None,
+    fingerprint: str | None = None,
+) -> requests.Response | None:
+    """Create a GitHub issue using the configured repository and token."""
+
+    payload = build_issue_payload(title, body, labels=labels, fingerprint=fingerprint)
+    if payload is None:
+        return None
+
+    owner, repo = resolve_repository()
+    token = get_github_token()
+
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "Authorization": f"token {token}",
+        "User-Agent": "arthexis-runtime-reporter",
+    }
+    url = f"https://api.github.com/repos/{owner}/{repo}/issues"
+
+    response = requests.post(
+        url, json=payload, headers=headers, timeout=REQUEST_TIMEOUT
+    )
+    if not (200 <= response.status_code < 300):
+        logger.error(
+            "GitHub issue creation failed with status %s: %s",
+            response.status_code,
+            response.text,
+        )
+        response.raise_for_status()
+
+    logger.info(
+        "GitHub issue created for %s/%s with status %s",
+        owner,
+        repo,
+        response.status_code,
+    )
+    return response

core/github_repos.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import logging
+from typing import Mapping
+
+import requests
+
+from .github_issues import REQUEST_TIMEOUT, get_github_token
+
+
+logger = logging.getLogger(__name__)
+
+
+def _build_repository_payload(
+    repo: str,
+    visibility: str,
+    description: str | None,
+) -> Mapping[str, object]:
+    payload: dict[str, object] = {"name": repo, "visibility": visibility}
+
+    if description is not None:
+        payload["description"] = description
+
+    return payload
+
+
+def create_repository(
+    owner: str | None,
+    repo: str,
+    *,
+    visibility: str = "private",
+    description: str | None = None,
+) -> requests.Response:
+    """Create a GitHub repository for the authenticated user or organisation."""
+
+    token = get_github_token()
+
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "Authorization": f"token {token}",
+        "User-Agent": "arthexis-runtime-reporter",
+    }
+
+    if owner:
+        url = f"https://api.github.com/orgs/{owner}/repos"
+    else:
+        url = "https://api.github.com/user/repos"
+
+    payload = _build_repository_payload(repo, visibility, description)
+
+    response = requests.post(
+        url,
+        json=payload,
+        headers=headers,
+        timeout=REQUEST_TIMEOUT,
+    )
+
+    if not (200 <= response.status_code < 300):
+        logger.error(
+            "GitHub repository creation failed with status %s: %s",
+            response.status_code,
+            response.text,
+        )
+        response.raise_for_status()
+
+    logger.info(
+        "GitHub repository created for %s with status %s",
+        owner or "authenticated user",
+        response.status_code,
+    )
+
+    return response