gwc-pybundle 0.4.2__py3-none-any.whl

pybundle/runner.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+import shutil
+from dataclasses import asdict
+
+from .context import BundleContext
+from .packaging import archive_output_path, make_archive, resolve_archive_format
+from .manifest import write_manifest
+from .steps.base import StepResult
+
+
+def run_profile(ctx: BundleContext, profile) -> int:
+    ctx.write_runlog(f"=== pybundle run {profile.name} ===")
+    ctx.write_runlog(f"ROOT: {ctx.root}")
+    ctx.write_runlog(f"WORK: {ctx.workdir}")
+
+    ctx.results.clear()
+    results: list[StepResult] = ctx.results
+    any_fail = False
+
+    for step in profile.steps:
+        ctx.write_runlog(f"-- START: {step.name}")
+        r = step.run(ctx)
+        results.append(r)
+        ctx.results = results
+        ctx.write_runlog(
+            f"-- DONE:  {step.name} [{r.status}] ({r.seconds}s) {r.note}".rstrip()
+        )
+        if r.status == "FAIL":
+            any_fail = True
+            if ctx.strict:
+                break
+
+    ctx.summary_json.write_text(
+        json.dumps(
+            {
+                "profile": profile.name,
+                "root": str(ctx.root),
+                "workdir": str(ctx.workdir),
+                "results": [asdict(r) for r in results],
+            },
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+
+    ctx.results = results
+
+    # Write the manifest BEFORE archiving so it's included inside the bundle.
+    archive_fmt_used = resolve_archive_format(ctx)
+    archive_path = archive_output_path(ctx, archive_fmt_used)
+    write_manifest(
+        ctx=ctx,
+        profile_name=profile.name,
+        archive_path=archive_path,
+        archive_format_used=archive_fmt_used,
+    )
+
+    archive_path, archive_fmt_used = make_archive(ctx)
+    ctx.write_runlog(f"ARCHIVE: {archive_path}")
+
+    print(f"✅ Archive created: {archive_path}")
+    if ctx.keep_workdir:
+        print(f"📁 Workdir kept:     {ctx.workdir}")
+
+    if not ctx.keep_workdir:
+        shutil.rmtree(ctx.workdir, ignore_errors=True)
+
+    if any_fail and ctx.strict:
+        return 10
+    return 0

pybundle/steps/base.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+from ..context import BundleContext
+
+
+@dataclass
+class StepResult:
+    name: str
+    status: str  # "PASS" | "FAIL" | "SKIP"
+    seconds: int
+    note: str = ""
+
+
+class Step(Protocol):
+    name: str
+
+    def run(self, ctx: BundleContext) -> StepResult: ...

pybundle/steps/compileall.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+
+
+def _guess_targets(root: Path) -> list[str]:
+    """
+    Heuristic targets:
+    - If there are top-level Python package dirs (contain __init__.py), compile those.
+    - Otherwise compile '.' (repo root).
+    """
+    targets: list[str] = []
+
+    for p in sorted(root.iterdir()):
+        if not p.is_dir():
+            continue
+        if p.name.startswith("."):
+            continue
+        if (p / "__init__.py").is_file():
+            targets.append(p.name)
+
+    return targets or ["."]
+
+
+@dataclass
+class CompileAllStep:
+    name: str = "compileall"
+    quiet: bool = True
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.logdir / "30_compileall.txt"
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        py = ctx.tools.python
+        if not py:
+            out.write_text("python not found; skipping compileall\n", encoding="utf-8")
+            return StepResult(self.name, "SKIP", 0, "missing python")
+
+        targets = _guess_targets(ctx.root)
+        cmd = [py, "-m", "compileall"]
+        if self.quiet:
+            cmd.append("-q")
+        cmd.extend(targets)
+
+        header = (
+            f"## PWD: {ctx.root}\n## CMD: {' '.join(cmd)}\n## TARGETS: {targets}\n\n"
+        )
+
+        try:
+            cp = subprocess.run(
+                cmd,
+                cwd=str(ctx.root),
+                text=True,
+                capture_output=True,
+                check=False,
+            )
+            text = header + (cp.stdout or "") + ("\n" + cp.stderr if cp.stderr else "")
+            out.write_text(ctx.redact_text(text), encoding="utf-8")
+            dur = int(time.time() - start)
+
+            # compileall uses non-zero for compile failures; we record it but don't fail bundling.
+            note = "" if cp.returncode == 0 else f"exit={cp.returncode} (recorded)"
+            return StepResult(self.name, "PASS", dur, note)
+        except Exception as e:
+            out.write_text(
+                ctx.redact_text(header + f"\nEXCEPTION: {e}\n"), encoding="utf-8"
+            )
+            dur = int(time.time() - start)
+            return StepResult(self.name, "PASS", dur, f"exception recorded: {e}")

pybundle/steps/context_expand.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import ast
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+
+
+def _read_lines(p: Path) -> list[str]:
+    if not p.is_file():
+        return []
+    return [
+        ln.strip()
+        for ln in p.read_text(encoding="utf-8", errors="replace").splitlines()
+        if ln.strip()
+    ]
+
+
+def _is_under(root: Path, p: Path) -> bool:
+    try:
+        p.resolve().relative_to(root.resolve())
+        return True
+    except Exception:
+        return False
+
+
+def _copy_file(src: Path, dst: Path) -> bool:
+    try:
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        dst.write_bytes(src.read_bytes())
+        return True
+    except Exception:
+        return False
+
+
+def _find_repo_candidates(root: Path) -> list[Path]:
+    cands = [root]
+    if (root / "src").is_dir():
+        cands.append(root / "src")
+    return cands
+
+
+def _module_to_path(roots: list[Path], module: str) -> Path | None:
+    """
+    Resolve an absolute module like 'pkg.sub' to a file inside repo roots:
+      - <root>/pkg/sub.py
+      - <root>/pkg/sub/__init__.py
+    """
+    parts = module.split(".")
+    for r in roots:
+        f1 = r.joinpath(*parts).with_suffix(".py")
+        if f1.is_file():
+            return f1
+        f2 = r.joinpath(*parts) / "__init__.py"
+        if f2.is_file():
+            return f2
+    return None
+
+
+def _relative_module_to_path(
+    roots: list[Path], base_file: Path, module: str | None, level: int
+) -> Path | None:
+    """
+    Resolve relative imports like:
+      from . import x      (level=1, module=None)
+      from ..foo import y  (level=2, module="foo")
+    """
+    # Find the package directory for base_file
+    base_dir = base_file.parent
+
+    # Move up `level` package levels
+    rel_dir = base_dir
+    for _ in range(level):
+        rel_dir = rel_dir.parent
+
+    if module:
+        target = rel_dir.joinpath(*module.split("."))
+    else:
+        target = rel_dir
+
+    # Try module as file or package
+    f1 = target.with_suffix(".py")
+    if f1.is_file():
+        return f1
+    f2 = target / "__init__.py"
+    if f2.is_file():
+        return f2
+
+    # If relative resolution fails, try absolute resolution as fallback
+    if module:
+        return _module_to_path(roots, module)
+    return None
+
+
+def _extract_import_modules(py_file: Path) -> set[tuple[str | None, int]]:
+    """
+    Returns a set of (module, level) pairs:
+      - absolute imports: (module, 0)
+      - relative imports: (module, level>=1)
+    module can be None for `from . import x` style.
+    """
+    out: set[tuple[str | None, int]] = set()
+    try:
+        src = py_file.read_text(encoding="utf-8", errors="replace")
+        tree = ast.parse(src)
+    except Exception:
+        return out
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name:
+                    out.add((alias.name, 0))
+        elif isinstance(node, ast.ImportFrom):
+            # node.module can be None (from . import x)
+            lvl = int(getattr(node, "level", 0) or 0)
+            mod = node.module
+            if mod:
+                out.add((mod, lvl))
+            else:
+                # still useful; we can resolve to the package itself for context
+                out.add((None, lvl))
+    return out
+
+
+def _add_package_chain(files: set[Path], root: Path, py: Path) -> None:
+    """
+    Add __init__.py from file's dir up to repo root.
+    """
+    cur = py.parent
+    root_res = root.resolve()
+    while True:
+        initp = cur / "__init__.py"
+        if initp.is_file():
+            files.add(initp)
+        if cur.resolve() == root_res:
+            break
+        if not _is_under(root, cur):
+            break
+        cur = cur.parent
+
+
+def _add_conftest_chain(files: set[Path], root: Path, py: Path) -> None:
+    """
+    Add conftest.py from file's dir up to repo root (pytest glue).
+    """
+    cur = py.parent
+    root_res = root.resolve()
+    while True:
+        cp = cur / "conftest.py"
+        if cp.is_file():
+            files.add(cp)
+        if cur.resolve() == root_res:
+            break
+        if not _is_under(root, cur):
+            break
+        cur = cur.parent
+
+
+@dataclass
+class ErrorContextExpandStep:
+    name: str = "expand error context"
+    depth: int = 2
+    max_files: int = 600
+    # reads this list produced by step 8
+    source_list_file: str = "error_files_from_logs.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        roots = _find_repo_candidates(ctx.root)
+
+        list_path = ctx.workdir / self.source_list_file
+        rels = _read_lines(list_path)
+
+        dest_root = ctx.srcdir / "_error_context"
+        dest_root.mkdir(parents=True, exist_ok=True)
+
+        to_copy: set[Path] = set()
+        queue: list[tuple[Path, int]] = []
+
+        # Seed with referenced python files only
+        for rel_str in rels:
+            p = (ctx.root / rel_str).resolve()
+            if p.is_file() and p.suffix == ".py" and _is_under(ctx.root, p):
+                queue.append((p, 0))
+                to_copy.add(p)
+
+        visited: set[Path] = set()
+
+        while queue and len(to_copy) < self.max_files:
+            py_file, d = queue.pop(0)
+            if py_file in visited:
+                continue
+            visited.add(py_file)
+
+            # add pytest + package glue around this file
+            _add_package_chain(to_copy, ctx.root, py_file)
+            _add_conftest_chain(to_copy, ctx.root, py_file)
+
+            if d >= self.depth:
+                continue
+
+            # parse imports and resolve to repo files
+            for mod, level in _extract_import_modules(py_file):
+                target: Path | None
+                if level and level > 0:
+                    target = _relative_module_to_path(roots, py_file, mod, level)
+                else:
+                    if not mod:
+                        continue
+                    target = _module_to_path(roots, mod)
+
+                if target and target.is_file() and _is_under(ctx.root, target):
+                    if target.suffix == ".py":
+                        if target not in to_copy:
+                            to_copy.add(target)
+                        queue.append((target, d + 1))
+
+                if len(to_copy) >= self.max_files:
+                    break
+
+        # Always include top-level config files if present (small but high value)
+        for cfg in [
+            "pyproject.toml",
+            "mypy.ini",
+            "ruff.toml",
+            ".ruff.toml",
+            "pytest.ini",
+            "setup.cfg",
+            "requirements.txt",
+        ]:
+            p = ctx.root / cfg
+            if p.is_file():
+                to_copy.add(p)
+
+        copied = 0
+        for p in sorted(to_copy):
+            if copied >= self.max_files:
+                break
+            # copy under src/_error_context/<repo-relative-path>
+            try:
+                rel_path = p.resolve().relative_to(ctx.root.resolve())
+            except Exception:
+                continue
+            dst = dest_root / rel_path
+            if _copy_file(p, dst):
+                copied += 1
+
+        report = ctx.metadir / "61_error_context_report.txt"
+        report.write_text(
+            "\n".join(
+                [
+                    f"seed_files={len([r for r in rels if r.endswith('.py')])}",
+                    f"depth={self.depth}",
+                    f"max_files={self.max_files}",
+                    f"resolved_total={len(to_copy)}",
+                    f"copied={copied}",
+                    "dest=src/_error_context",
+                ]
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+
+        dur = int(time.time() - start)
+        note = f"resolved={len(to_copy)} copied={copied}"
+        if copied >= self.max_files:
+            note += " (HIT MAX)"
+        return StepResult(self.name, "PASS", dur, note)