arthexis 0.1.9__py3-none-any.whl → 0.1.26__py3-none-any.whl

core/github_issues.py

@@ -1,172 +1,183 @@
-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 is not None:
+            cleaned = token.strip() if isinstance(token, str) else str(token).strip()
+            if cleaned:
+                return cleaned
+
+    env_token = os.environ.get("GITHUB_TOKEN")
+    if env_token is not None:
+        cleaned = env_token.strip() if isinstance(env_token, str) else str(env_token).strip()
+        if cleaned:
+            return cleaned
+
+    raise RuntimeError("GitHub token is not configured")
+
+
+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

core/lcd_screen.py

@@ -1,78 +1,78 @@
-"""Standalone LCD screen updater.
-
-The script polls ``locks/lcd_screen.lck`` for up to two lines of text and
-writes them to the attached LCD1602 display. If either line exceeds 16
-characters the text scrolls horizontally. A third line in the lock file
-can define the scroll speed in milliseconds per character (default 1000
-ms).
-"""
-
-from __future__ import annotations
-
-import logging
-import time
-from pathlib import Path
-
-from nodes.lcd import CharLCD1602, LCDUnavailableError
-
-logger = logging.getLogger(__name__)
-
-LOCK_FILE = Path(__file__).resolve().parents[1] / "locks" / "lcd_screen.lck"
-DEFAULT_SCROLL_MS = 1000
-
-
-def _read_lock_file() -> tuple[str, str, int]:
-    try:
-        lines = LOCK_FILE.read_text(encoding="utf-8").splitlines()
-    except FileNotFoundError:
-        return "", "", DEFAULT_SCROLL_MS
-    line1 = lines[0][:64] if len(lines) > 0 else ""
-    line2 = lines[1][:64] if len(lines) > 1 else ""
-    try:
-        speed = int(lines[2]) if len(lines) > 2 else DEFAULT_SCROLL_MS
-    except ValueError:
-        speed = DEFAULT_SCROLL_MS
-    return line1, line2, speed
-
-
-def _display(lcd: CharLCD1602, line1: str, line2: str, scroll_ms: int) -> None:
-    scroll_sec = max(scroll_ms, 0) / 1000.0
-    text1 = line1[:64]
-    text2 = line2[:64]
-    pad1 = text1 + " " * 16 if len(text1) > 16 else text1.ljust(16)
-    pad2 = text2 + " " * 16 if len(text2) > 16 else text2.ljust(16)
-    steps = max(len(pad1) - 15, len(pad2) - 15)
-    for i in range(steps):
-        segment1 = pad1[i : i + 16]
-        segment2 = pad2[i : i + 16]
-        lcd.write(0, 0, segment1.ljust(16))
-        lcd.write(0, 1, segment2.ljust(16))
-        time.sleep(scroll_sec)
-
-
-def main() -> None:  # pragma: no cover - hardware dependent
-    lcd = None
-    last_mtime = 0.0
-    while True:
-        try:
-            if LOCK_FILE.exists():
-                mtime = LOCK_FILE.stat().st_mtime
-                if mtime != last_mtime or lcd is None:
-                    line1, line2, speed = _read_lock_file()
-                    if lcd is None:
-                        lcd = CharLCD1602()
-                        lcd.init_lcd()
-                    lcd.clear()
-                    _display(lcd, line1, line2, speed)
-                    last_mtime = mtime
-        except LCDUnavailableError as exc:
-            logger.warning("LCD unavailable: %s", exc)
-            lcd = None
-        except Exception as exc:
-            logger.warning("LCD update failed: %s", exc)
-            lcd = None
-        time.sleep(0.5)
-
-
-if __name__ == "__main__":  # pragma: no cover - script entry point
-    main()
+"""Standalone LCD screen updater.
+
+The script polls ``locks/lcd_screen.lck`` for up to two lines of text and
+writes them to the attached LCD1602 display. If either line exceeds 16
+characters the text scrolls horizontally. A third line in the lock file
+can define the scroll speed in milliseconds per character (default 1000
+ms).
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+
+from nodes.lcd import CharLCD1602, LCDUnavailableError
+
+logger = logging.getLogger(__name__)
+
+LOCK_FILE = Path(__file__).resolve().parents[1] / "locks" / "lcd_screen.lck"
+DEFAULT_SCROLL_MS = 1000
+
+
+def _read_lock_file() -> tuple[str, str, int]:
+    try:
+        lines = LOCK_FILE.read_text(encoding="utf-8").splitlines()
+    except FileNotFoundError:
+        return "", "", DEFAULT_SCROLL_MS
+    line1 = lines[0][:64] if len(lines) > 0 else ""
+    line2 = lines[1][:64] if len(lines) > 1 else ""
+    try:
+        speed = int(lines[2]) if len(lines) > 2 else DEFAULT_SCROLL_MS
+    except ValueError:
+        speed = DEFAULT_SCROLL_MS
+    return line1, line2, speed
+
+
+def _display(lcd: CharLCD1602, line1: str, line2: str, scroll_ms: int) -> None:
+    scroll_sec = max(scroll_ms, 0) / 1000.0
+    text1 = line1[:64]
+    text2 = line2[:64]
+    pad1 = text1 + " " * 16 if len(text1) > 16 else text1.ljust(16)
+    pad2 = text2 + " " * 16 if len(text2) > 16 else text2.ljust(16)
+    steps = max(len(pad1) - 15, len(pad2) - 15)
+    for i in range(steps):
+        segment1 = pad1[i : i + 16]
+        segment2 = pad2[i : i + 16]
+        lcd.write(0, 0, segment1.ljust(16))
+        lcd.write(0, 1, segment2.ljust(16))
+        time.sleep(scroll_sec)
+
+
+def main() -> None:  # pragma: no cover - hardware dependent
+    lcd = None
+    last_mtime = 0.0
+    while True:
+        try:
+            if LOCK_FILE.exists():
+                mtime = LOCK_FILE.stat().st_mtime
+                if mtime != last_mtime or lcd is None:
+                    line1, line2, speed = _read_lock_file()
+                    if lcd is None:
+                        lcd = CharLCD1602()
+                        lcd.init_lcd()
+                    lcd.clear()
+                    _display(lcd, line1, line2, speed)
+                    last_mtime = mtime
+        except LCDUnavailableError as exc:
+            logger.warning("LCD unavailable: %s", exc)
+            lcd = None
+        except Exception as exc:
+            logger.warning("LCD update failed: %s", exc)
+            lcd = None
+        time.sleep(0.5)
+
+
+if __name__ == "__main__":  # pragma: no cover - script entry point
+    main()

core/liveupdate.py

@@ -1,25 +1,25 @@
-from functools import wraps
-
-
-def live_update(interval=5):
-    """Decorator to mark function-based views for automatic refresh."""
-
-    def decorator(view):
-        @wraps(view)
-        def wrapped(request, *args, **kwargs):
-            setattr(request, "live_update_interval", interval)
-            return view(request, *args, **kwargs)
-
-        return wrapped
-
-    return decorator
-
-
-class LiveUpdateMixin:
-    """Mixin to enable automatic refresh for class-based views."""
-
-    live_update_interval = 5
-
-    def dispatch(self, request, *args, **kwargs):
-        setattr(request, "live_update_interval", self.live_update_interval)
-        return super().dispatch(request, *args, **kwargs)
+from functools import wraps
+
+
+def live_update(interval=5):
+    """Decorator to mark function-based views for automatic refresh."""
+
+    def decorator(view):
+        @wraps(view)
+        def wrapped(request, *args, **kwargs):
+            setattr(request, "live_update_interval", interval)
+            return view(request, *args, **kwargs)
+
+        return wrapped
+
+    return decorator
+
+
+class LiveUpdateMixin:
+    """Mixin to enable automatic refresh for class-based views."""
+
+    live_update_interval = 5
+
+    def dispatch(self, request, *args, **kwargs):
+        setattr(request, "live_update_interval", self.live_update_interval)
+        return super().dispatch(request, *args, **kwargs)