gitacross 1.0.0__py3-none-any.whl

gitacross/providers/gitea.py

@@ -0,0 +1,170 @@
+"""Gitea provider — REST API client for Gitea instances."""
+
+import io
+import json
+import logging
+import shutil
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from pathlib import Path
+
+from .base import BaseAPIClient
+
+logger = logging.getLogger(__name__)
+
+
+class _MultipartReader:
+    """File-like object that streams multipart/form-data without buffering the attachment.
+
+    Yields: boundary_header_bytes → file_content_chunks → boundary_footer_bytes.
+    The caller computes ``Content-Length = len(header) + file_size + len(footer)``
+    upfront so HTTP/1.1 chunked-encoding is not required.
+    """
+
+    def __init__(self, header: bytes, file_path, footer: bytes):
+        self._parts = [io.BytesIO(header), open(file_path, "rb"), io.BytesIO(footer)]
+        self._idx = 0
+
+    def read(self, size=-1):
+        if size == 0:
+            return b""
+        chunks = []
+        remaining = size
+        while self._idx < len(self._parts):
+            chunk = self._parts[self._idx].read(remaining if remaining > 0 else -1)
+            if chunk:
+                chunks.append(chunk)
+                if remaining > 0:
+                    remaining -= len(chunk)
+                    if remaining <= 0:
+                        break
+            else:
+                self._idx += 1
+        return b"".join(chunks)
+
+    def close(self):
+        for part in self._parts:
+            try:
+                part.close()
+            except Exception:
+                pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+class GiteaClient(BaseAPIClient):
+    """Gitea REST API client.
+
+    Differences from the base:
+    - Auth header uses ``token <tok>`` (not Bearer)
+    - Release conflict code is 409 (not 422)
+    - Asset upload uses multipart/form-data
+    - Asset download falls back to constructing a URL from asset IDs
+    """
+
+    _platform_name = "Gitea"
+    _conflict_codes = (409, 422)
+    _release_conflict_code = 409
+
+    def __init__(self, api: str, repo: str, token: str):
+        super().__init__(api, repo, token)
+        self._headers = {
+            "Authorization": f"token {token}",
+            "Accept": "application/json",
+        }
+
+    # ------------------------------------------------------------------
+    # Asset management
+    # ------------------------------------------------------------------
+
+    def download_asset(self, asset, dest):
+        """Download a Gitea release asset to *dest*."""
+        url = asset.get("browser_download_url") or ""
+        if not url and asset.get("id") and asset.get("release_id"):
+            url = (
+                f"{self.api}/repos/{self.repo}/releases"
+                f"/{asset['release_id']}/assets/{asset['id']}"
+            )
+        if not url:
+            raise ValueError(f"Asset has no download URL: {asset}")
+        # Gitea can return a relative URL for self-hosted instances
+        if url.startswith("/"):
+            host_base = self.api.split("/api")[0]
+            url = f"{host_base}{url}"
+        headers = dict(self._headers)
+        headers["Accept"] = "*/*"
+        req = urllib.request.Request(url, headers=headers)
+        with urllib.request.urlopen(req) as resp, open(dest, "wb") as f:
+            shutil.copyfileobj(resp, f)
+
+    def upload_asset(self, release_or_id, file_path, name=None, stream=False):
+        """Upload an asset to a Gitea release using multipart/form-data.
+
+        Idempotent — returns ``None`` if the asset already exists (409/422).
+
+        When *stream* is ``True`` the file content is never fully loaded into
+        RAM: a ``_MultipartReader`` wraps the boundary bytes + file handle and
+        is passed directly to ``urllib``. ``Content-Length`` is pre-computed
+        from ``len(header) + file_size + len(footer)`` so chunked encoding is
+        not needed.
+        """
+        name = name or Path(file_path).name
+        rel_id = (
+            release_or_id.get("id")
+            if isinstance(release_or_id, dict)
+            else release_or_id
+        )
+        url = (
+            f"{self.api}/repos/{self.repo}/releases/{rel_id}/assets"
+            f"?name={urllib.parse.quote(name)}"
+        )
+        boundary = f"----GitAcrossBoundary{uuid.uuid4().hex}"
+        header_bytes = (
+            f"--{boundary}\r\n"
+            f'Content-Disposition: form-data; name="attachment"; filename="{name}"\r\n'
+            f"Content-Type: application/octet-stream\r\n\r\n"
+        ).encode("utf-8")
+        footer_bytes = f"\r\n--{boundary}--\r\n".encode("utf-8")
+
+        req_headers = {
+            "Authorization": self._headers["Authorization"],
+            "Accept": "application/json",
+            "Content-Type": f"multipart/form-data; boundary={boundary}",
+        }
+
+        try:
+            if stream:
+                file_size = Path(file_path).stat().st_size
+                content_length = len(header_bytes) + file_size + len(footer_bytes)
+                req_headers["Content-Length"] = str(content_length)
+                with _MultipartReader(header_bytes, file_path, footer_bytes) as body:
+                    req = urllib.request.Request(
+                        url, data=body, headers=req_headers, method="POST"
+                    )
+                    with urllib.request.urlopen(req) as resp:
+                        raw = resp.read()
+                        return json.loads(raw) if raw else None
+            else:
+                with open(file_path, "rb") as f:
+                    file_bytes = f.read()
+                body = header_bytes + file_bytes + footer_bytes
+                req_headers["Content-Length"] = str(len(body))
+                req = urllib.request.Request(
+                    url, data=body, headers=req_headers, method="POST"
+                )
+                with urllib.request.urlopen(req) as resp:
+                    raw = resp.read()
+                    return json.loads(raw) if raw else None
+        except urllib.error.HTTPError as e:
+            if e.code in (409, 422):
+                logger.info("Asset %s already exists on Gitea (idempotent)", name)
+                return None
+            body_text = e.read().decode()
+            logger.error("Gitea upload asset error %s: %s", e.code, body_text)
+            raise

gitacross/providers/github.py

@@ -0,0 +1,120 @@
+"""GitHub provider — REST API client for github.com and GitHub Enterprise."""
+
+import json
+import logging
+import shutil
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+from .base import BaseAPIClient
+
+logger = logging.getLogger(__name__)
+
+
+class GitHubClient(BaseAPIClient):
+    """GitHub REST API client.
+
+    Differences from the base:
+    - Auth header uses ``Bearer <tok>``
+    - ``Accept: application/vnd.github+json``
+    - Release pagination uses ``per_page`` (not ``limit``)
+    - Release conflict code is 422 (not 409)
+    - Asset upload uses raw ``application/octet-stream`` to the upload endpoint
+    - Asset download requires ``Accept: application/octet-stream``
+    """
+
+    _platform_name = "GitHub"
+    _conflict_codes = (409, 422)
+    _release_conflict_code = 422
+
+    def __init__(self, api: str, repo: str, token: str):
+        super().__init__(api, repo, token)
+        self._headers = {
+            "Authorization": f"Bearer {token}",
+            "Accept": "application/vnd.github+json",
+        }
+
+    def list_releases(self, page=1, limit=50):
+        """GitHub uses ``per_page`` instead of ``limit``."""
+        return self._request("GET", f"releases?page={page}&per_page={limit}")
+
+    # ------------------------------------------------------------------
+    # Asset management
+    # ------------------------------------------------------------------
+
+    def download_asset(self, asset, dest):
+        """Download a GitHub release asset to *dest*."""
+        url = asset.get("url") or asset.get("browser_download_url")
+        if not url:
+            raise ValueError(f"Asset has no download URL: {asset}")
+        headers = dict(self._headers)
+        headers["Accept"] = "application/octet-stream"
+        req = urllib.request.Request(url, headers=headers)
+        with urllib.request.urlopen(req) as resp, open(dest, "wb") as f:
+            shutil.copyfileobj(resp, f)
+
+    def upload_asset(self, release_or_id, file_path, name=None, stream=False):
+        """Upload an asset to a GitHub release as raw ``application/octet-stream``.
+
+        Idempotent — returns ``None`` if the asset already exists (422).
+
+        When *stream* is ``True`` the file object is passed directly to
+        ``urllib`` so the content is read in chunks rather than all at once.
+        ``Content-Length`` is set from ``file.stat().st_size`` so no
+        chunked-encoding handshake is needed.
+        """
+        name = name or Path(file_path).name
+        upload_url = None
+        if isinstance(release_or_id, dict):
+            upload_url = release_or_id.get("upload_url")
+            rel_id = release_or_id.get("id")
+        else:
+            rel_id = release_or_id
+
+        # Resolve the upload base URL (prefer the API-returned upload_url).
+        if upload_url:
+            base_url = upload_url.split("{")[0]
+        elif self.api == "https://api.github.com":
+            base_url = (
+                f"https://uploads.github.com/repos/{self.repo}/releases/{rel_id}/assets"
+            )
+        else:
+            base_url = f"{self.api}/repos/{self.repo}/releases/{rel_id}/assets"
+
+        url = f"{base_url}?name={urllib.parse.quote(name)}"
+        req_headers = {
+            "Authorization": self._headers["Authorization"],
+            "Accept": "application/vnd.github+json",
+            "Content-Type": "application/octet-stream",
+        }
+
+        try:
+            if stream:
+                file_size = Path(file_path).stat().st_size
+                req_headers["Content-Length"] = str(file_size)
+                with open(file_path, "rb") as f:
+                    req = urllib.request.Request(
+                        url, data=f, headers=req_headers, method="POST"
+                    )
+                    with urllib.request.urlopen(req) as resp:
+                        raw = resp.read()
+                        return json.loads(raw) if raw else None
+            else:
+                with open(file_path, "rb") as f:
+                    data = f.read()
+                req_headers["Content-Length"] = str(len(data))
+                req = urllib.request.Request(
+                    url, data=data, headers=req_headers, method="POST"
+                )
+                with urllib.request.urlopen(req) as resp:
+                    raw = resp.read()
+                    return json.loads(raw) if raw else None
+        except urllib.error.HTTPError as e:
+            if e.code == 422:
+                logger.info("Asset %s already exists on GitHub (idempotent)", name)
+                return None
+            body_text = e.read().decode()
+            logger.error("GitHub upload asset error %s: %s", e.code, body_text)
+            raise

gitacross/renderer.py

@@ -0,0 +1,195 @@
+import fnmatch
+import logging
+import re
+import shutil
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def apply_operations(work_dir, project):
+    """Run the full render pipeline on *work_dir* after source tag overlay.
+
+    1. Remove paths in `ignore` (glob list, always first).
+    2. Apply `operations` in declaration order.
+    """
+    work = Path(work_dir)
+
+    for pattern in project.renderer.ignore:
+        _remove_glob(work, pattern)
+
+    for op in project.renderer.operations:
+        if "remove" in op:
+            _op_remove(work, op["remove"])
+        elif "rename" in op:
+            _op_rename(work, op["rename"])
+        elif "replace" in op:
+            _op_replace(work, op["replace"])
+        elif "add" in op:
+            _op_add(work, op["add"])
+        elif "validate" in op:
+            _op_validate(work, op["validate"])
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _remove_glob(root, pattern):
+    """Remove all files/dirs matching a glob pattern relative to *root*."""
+    paths = sorted(root.rglob(pattern), key=lambda p: len(str(p)), reverse=True)
+    for path in paths:
+        if not path.exists():
+            continue
+        if path.is_dir() and not path.is_symlink():
+            shutil.rmtree(path)
+        else:
+            path.unlink()
+    _clean_empty_dirs(root)
+
+
+def _clean_empty_dirs(root):
+    for path in sorted(root.rglob("*"), key=lambda p: len(str(p)), reverse=True):
+        if path.is_dir() and not any(path.iterdir()):
+            path.rmdir()
+
+
+def _iter_files(root):
+    for path in root.rglob("*"):
+        if path.is_file():
+            yield path
+
+
+# ---------------------------------------------------------------------------
+# Operation handlers
+# ---------------------------------------------------------------------------
+
+
+def _op_remove(work, ops):
+    """Remove matching files/dirs.
+    Each op: {path: str, pattern?: literal|glob|regex}
+    """
+    for op in ops:
+        pat = op.get("path", "")
+        mode = op.get("pattern", "literal")
+        if mode == "literal":
+            target = work / pat
+            if target.exists():
+                if target.is_dir():
+                    shutil.rmtree(target)
+                else:
+                    target.unlink()
+        elif mode == "glob":
+            _remove_glob(work, pat)
+        elif mode == "regex":
+            for f in _iter_files(work):
+                if re.search(pat, str(f.relative_to(work))):
+                    f.unlink()
+            _clean_empty_dirs(work)
+
+
+def _op_rename(work, ops):
+    """Rename files/dirs. Processes deepest paths first to avoid parent conflicts.
+
+    Each op: {from: str, to: str, pattern?: literal|glob|regex}
+    """
+    # ponytail: only literal renames are implemented. Glob/regex rename raises.
+    for op in sorted(ops, key=lambda o: -len(o.get("from", ""))):
+        mode = op.get("pattern", "literal")
+        if mode != "literal":
+            raise NotImplementedError(
+                f"Rename pattern '{mode}' is not yet implemented — use 'literal'"
+            )
+
+        src = work / op["from"]
+        dst = work / op["to"]
+        if src.exists():
+            if dst.exists():
+                raise RuntimeError(f"Rename conflict: {op['to']} already exists")
+            src.rename(dst)
+
+
+def _op_replace(work, ops):
+    """Search-and-replace in UTF-8 text files.
+
+    Each op: {search: str, replace: str, pattern?: literal|regex, glob?: str, path?: str}
+    """
+    for op in ops:
+        search = op["search"]
+        replace = op["replace"]
+        mode = op.get("pattern", "literal")
+        path_filter = op.get("path")
+        glob_filter = op.get("glob")
+
+        for f in _iter_files(work):
+            rel = f.relative_to(work)
+            if path_filter:
+                if str(rel) != path_filter:
+                    continue
+            elif glob_filter:
+                if not fnmatch.fnmatch(str(rel), glob_filter):
+                    continue
+
+            try:
+                text = f.read_text("utf-8")
+            except (UnicodeDecodeError, ValueError):
+                continue
+
+            new_text = (
+                re.sub(search, replace, text)
+                if mode == "regex"
+                else text.replace(search, replace)
+            )
+            if new_text != text:
+                f.write_text(new_text, encoding="utf-8")
+
+
+def _op_add(work, ops):
+    """Create files in the work tree before commit.
+
+    Each op: {path: str, content: str}
+    Raises if the path already exists (avoids silently overwriting).
+    Creates parent directories automatically.
+    """
+    for op in ops:
+        path = op["path"]
+        target = work / path
+        if target.exists():
+            raise RuntimeError(f"Add conflict: '{path}' already exists")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(op.get("content", ""), encoding="utf-8")
+        logger.debug("Added file: %s", path)
+
+
+def _op_validate(work, ops):
+    """Assert conditions on the final tree. Aborts on failure."""
+    for op in ops:
+        assert_type = op.get("assert", "")
+        path = op.get("path", "")
+        pattern = op.get("pattern", "")
+        target = work / path
+
+        if assert_type == "file_exists":
+            if not target.exists():
+                raise RuntimeError(f"Validation failed: '{path}' must exist")
+        elif assert_type == "file_absent":
+            if target.exists():
+                raise RuntimeError(f"Validation failed: '{path}' must not exist")
+        elif assert_type == "string_exists":
+            if not target.exists():
+                raise RuntimeError(
+                    f"Validation failed: '{path}' not found (for string_exists check)"
+                )
+            content = target.read_text("utf-8", errors="replace")
+            if pattern not in content:
+                raise RuntimeError(
+                    f"Validation failed: '{pattern}' not found in '{path}'"
+                )
+        elif assert_type == "string_absent":
+            if target.exists():
+                content = target.read_text("utf-8", errors="replace")
+                if pattern in content:
+                    raise RuntimeError(
+                        f"Validation failed: '{pattern}' found in '{path}'"
+                    )

gitacross/retry.py

@@ -0,0 +1,23 @@
+import logging
+import time
+
+logger = logging.getLogger(__name__)
+
+
+def retry(fn, max_attempts=3, backoff_seconds=2, exceptions=(Exception,)):
+    """Run fn with exponential backoff. Re-raises the last exception on final failure."""
+    for attempt in range(max_attempts):
+        try:
+            return fn()
+        except exceptions as e:
+            if attempt == max_attempts - 1:
+                raise
+            delay = backoff_seconds * (2**attempt)
+            logger.warning(
+                "Attempt %d/%d failed: %s. Retrying in %.1fs...",
+                attempt + 1,
+                max_attempts,
+                e,
+                delay,
+            )
+            time.sleep(delay)