pz-cli 5.0.0__py3-none-any.whl

pz_core/authoring/conflicts.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib import metadata
+import json
+import os
+from pathlib import Path
+import tomllib
+
+from pz_core.project_sources import resolve_sources_manifest_path
+from pz_core.runtime.errors import PzError
+
+
+@dataclass(frozen=True, slots=True)
+class AppBindingConflict:
+    app_id: str
+    local_paths: tuple[Path, ...]
+    installed_root: Path | None
+
+
+def _distribution_name(app_id: str) -> str:
+    return app_id.replace("_", "-")
+
+
+def _read_project_distribution_name(pyproject_path: Path) -> str | None:
+    if not pyproject_path.is_file():
+        return None
+    try:
+        payload = tomllib.loads(pyproject_path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+    project = payload.get("project")
+    if not isinstance(project, dict):
+        return None
+    name = project.get("name")
+    if not isinstance(name, str) or not name.strip():
+        return None
+    return name.strip()
+
+
+def find_local_app_sources(project_dir: Path, app_id: str) -> tuple[Path, ...]:
+    apps_root = project_dir / "apps"
+    matches: list[Path] = []
+    seen: set[Path] = set()
+
+    if apps_root.is_dir():
+        for root, dirnames, filenames in os.walk(apps_root, followlinks=True):
+            current_root = Path(root)
+            relative_root = current_root.relative_to(apps_root)
+            dirnames[:] = [dirname for dirname in dirnames if not dirname.startswith(".")]
+            if any(part.startswith(".") for part in relative_root.parts):
+                continue
+            if "pyproject.toml" not in filenames:
+                continue
+            distribution = _read_project_distribution_name(current_root / "pyproject.toml")
+            if distribution is None:
+                continue
+            if distribution.replace("-", "_") != app_id:
+                continue
+            resolved_root = current_root.resolve()
+            if resolved_root in seen:
+                continue
+            matches.append(resolved_root)
+            seen.add(resolved_root)
+
+    manifest_path = resolve_sources_manifest_path(project_dir)
+    if manifest_path.is_file():
+        try:
+            payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+        except Exception:
+            payload = {}
+        apps = payload.get("apps")
+        if isinstance(apps, dict):
+            app_meta = apps.get(app_id)
+            if isinstance(app_meta, dict):
+                raw_path = str(app_meta.get("path") or "").strip()
+                if raw_path:
+                    candidate = (project_dir / raw_path).resolve()
+                    if candidate.is_dir() and candidate not in seen:
+                        matches.append(candidate)
+                        seen.add(candidate)
+    return tuple(sorted(matches))
+
+
+def find_installed_distribution_root(app_id: str) -> Path | None:
+    try:
+        distribution = metadata.distribution(_distribution_name(app_id))
+    except metadata.PackageNotFoundError:
+        return None
+    return Path(distribution.locate_file("")).resolve()
+
+
+def collect_app_binding_conflicts(project_dir: Path, app_ids: tuple[str, ...]) -> tuple[AppBindingConflict, ...]:
+    conflicts: list[AppBindingConflict] = []
+    seen: set[str] = set()
+    for raw_app_id in app_ids:
+        app_id = str(raw_app_id).strip()
+        if not app_id or app_id in seen:
+            continue
+        seen.add(app_id)
+        local_paths = find_local_app_sources(project_dir, app_id)
+        installed_root = find_installed_distribution_root(app_id)
+        has_conflict = len(local_paths) > 1
+        if not has_conflict:
+            continue
+        conflicts.append(
+            AppBindingConflict(
+                app_id=app_id,
+                local_paths=local_paths,
+                installed_root=installed_root,
+            )
+        )
+    return tuple(conflicts)
+
+
+def build_app_binding_conflict_error(
+    project_dir: Path,
+    app_ids: tuple[str, ...],
+    *,
+    action: str,
+    command_label: str,
+    rollback_note: str | None = None,
+    conflicts: tuple[AppBindingConflict, ...] | None = None,
+) -> PzError:
+    conflicts = conflicts if conflicts is not None else collect_app_binding_conflicts(project_dir, app_ids)
+    detail_lines: list[str] = []
+    resolution_lines: list[str] = []
+    for conflict in conflicts:
+        if conflict.local_paths:
+            detail_lines.append(
+                f"{conflict.app_id}: apps={', '.join(str(path) for path in conflict.local_paths)}"
+            )
+        if conflict.installed_root is not None and len(conflict.local_paths) > 1:
+            detail_lines.append(f"{conflict.app_id}: site_packages={conflict.installed_root}")
+        if len(conflict.local_paths) > 1:
+            resolution_lines.append(
+                f"{conflict.app_id}: delete duplicate local sources under apps/ and keep exactly one package root"
+            )
+    if resolution_lines:
+        detail_lines.append("resolution=" + " | ".join(resolution_lines))
+    message = f"manual conflict resolution required after `{command_label}`."
+    if rollback_note:
+        message = f"{message} {rollback_note}"
+    return PzError(
+        code="PZ_SCAFFOLD_APP_CONFLICT",
+        message=message,
+        stage="cli",
+        owner="pz_core.authoring",
+        action=action,
+        detail="; ".join(detail_lines),
+    )
+
+
+def ensure_no_app_binding_conflicts(
+    project_dir: Path,
+    app_ids: tuple[str, ...],
+    *,
+    action: str,
+    command_label: str,
+) -> None:
+    conflicts = collect_app_binding_conflicts(project_dir, app_ids)
+    if not conflicts:
+        return
+    raise build_app_binding_conflict_error(
+        project_dir,
+        app_ids,
+        action=action,
+        command_label=command_label,
+        conflicts=conflicts,
+    )
+
+
+__all__ = [
+    "AppBindingConflict",
+    "build_app_binding_conflict_error",
+    "collect_app_binding_conflicts",
+    "ensure_no_app_binding_conflicts",
+    "find_installed_distribution_root",
+    "find_local_app_sources",
+]