peep-install 0.1.0__tar.gz

peep_install-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: peep-install
+Version: 0.1.0
+Summary: A smarter pip that auto-resolves version conflicts, build errors, and platform issues
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.28.0
+Requires-Dist: packaging>=23.0

peep_install-0.1.0/peep/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.1.0"
+__author__ = "peep-install"

peep_install-0.1.0/peep/build.py

@@ -0,0 +1,154 @@
+import shutil
+import subprocess
+import sys
+import platform
+from dataclasses import dataclass
+
+
+@dataclass
+class BuildRequirement:
+    name: str                  # Human-readable name e.g. "GCC compiler"
+    check_command: str         # Command to check if it exists e.g. "gcc"
+    install_apt: str | None    # apt package name
+    install_brew: str | None   # brew package name
+    install_hint: str | None   # Fallback manual hint if auto-install fails
+
+
+# Known build requirements mapped to PyPI package name fragments
+KNOWN_BUILD_DEPS: dict[str, list[BuildRequirement]] = {
+    "numpy": [
+        BuildRequirement("GCC compiler", "gcc", "gcc", "gcc", None),
+        BuildRequirement("Python headers", "python3-config", "python3-dev", None, "Install python3-dev"),
+    ],
+    "pillow": [
+        BuildRequirement("libjpeg", None, "libjpeg-dev", "jpeg", None),
+        BuildRequirement("zlib", None, "zlib1g-dev", "zlib", None),
+        BuildRequirement("GCC compiler", "gcc", "gcc", "gcc", None),
+    ],
+    "cryptography": [
+        BuildRequirement("Rust toolchain", "rustc", None, "rust", "Install from https://rustup.rs"),
+        BuildRequirement("GCC compiler", "gcc", "gcc", "gcc", None),
+        BuildRequirement("OpenSSL headers", None, "libssl-dev", "openssl", None),
+    ],
+    "lxml": [
+        BuildRequirement("libxml2", None, "libxml2-dev", "libxml2", None),
+        BuildRequirement("libxslt", None, "libxslt-dev", "libxslt", None),
+        BuildRequirement("GCC compiler", "gcc", "gcc", "gcc", None),
+    ],
+    "psycopg2": [
+        BuildRequirement("PostgreSQL headers", "pg_config", "libpq-dev", "postgresql", None),
+        BuildRequirement("GCC compiler", "gcc", "gcc", "gcc", None),
+    ],
+}
+
+# Generic build tools needed for any source compilation
+GENERIC_BUILD_DEPS = [
+    BuildRequirement("GCC compiler", "gcc", "build-essential", "gcc", None),
+    BuildRequirement("Python headers", "python3-config", "python3-dev", None, "Install python3-dev or python-dev"),
+    BuildRequirement("Make", "make", "make", "make", None),
+]
+
+
+def get_package_manager() -> str | None:
+    """Detect the available system package manager."""
+    if platform.system() == "Darwin":
+        if shutil.which("brew"):
+            return "brew"
+        return None
+    elif platform.system() == "Linux":
+        if shutil.which("apt-get"):
+            return "apt"
+        elif shutil.which("dnf"):
+            return "dnf"
+        elif shutil.which("pacman"):
+            return "pacman"
+        return None
+    return None
+
+
+def _is_present(req: BuildRequirement) -> bool:
+    """Check if a build requirement is already satisfied."""
+    if req.check_command:
+        return shutil.which(req.check_command) is not None
+    return False
+
+
+def _install_dep(req: BuildRequirement, pkg_manager: str) -> bool:
+    """Attempt to install a build dependency via the system package manager."""
+    pkg = None
+
+    if pkg_manager == "apt":
+        pkg = req.install_apt
+        cmd = ["sudo", "apt-get", "install", "-y", pkg] if pkg else None
+    elif pkg_manager == "brew":
+        pkg = req.install_brew
+        cmd = ["brew", "install", pkg] if pkg else None
+    elif pkg_manager == "dnf":
+        pkg = req.install_apt  # dnf package names are often the same as apt
+        cmd = ["sudo", "dnf", "install", "-y", pkg] if pkg else None
+    elif pkg_manager == "pacman":
+        pkg = req.install_apt
+        cmd = ["sudo", "pacman", "-S", "--noconfirm", pkg] if pkg else None
+    else:
+        return False
+
+    if not cmd:
+        return False
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+def check_and_fix_build_deps(package_name: str, needs_compilation: bool) -> dict:
+    """
+    Check for and silently fix missing build dependencies for a package.
+    Returns a report of what was found and what was done.
+    """
+    if not needs_compilation:
+        return {"needed": False}
+
+    pkg_manager = get_package_manager()
+    pkg_lower = package_name.lower()
+
+    # Gather required build deps: generic ones + any package-specific ones
+    required: list[BuildRequirement] = list(GENERIC_BUILD_DEPS)
+    for key, deps in KNOWN_BUILD_DEPS.items():
+        if key in pkg_lower or pkg_lower in key:
+            required.extend(deps)
+
+    # Deduplicate by name
+    seen = set()
+    unique_required = []
+    for r in required:
+        if r.name not in seen:
+            seen.add(r.name)
+            unique_required.append(r)
+
+    missing = [r for r in unique_required if not _is_present(r)]
+
+    if not missing:
+        return {"needed": True, "missing": [], "fixed": [], "failed": []}
+
+    fixed = []
+    failed = []
+
+    for req in missing:
+        if pkg_manager:
+            success = _install_dep(req, pkg_manager)
+            if success:
+                fixed.append(req.name)
+            else:
+                failed.append({"dep": req.name, "hint": req.install_hint})
+        else:
+            failed.append({"dep": req.name, "hint": req.install_hint})
+
+    return {
+        "needed": True,
+        "missing": [r.name for r in missing],
+        "fixed": fixed,
+        "failed": failed,
+        "pkg_manager": pkg_manager,
+    }

peep_install-0.1.0/peep/cli.py

@@ -0,0 +1,129 @@
+import argparse
+import sys
+from .installer import install, install_many
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="peep",
+        description="A smarter pip — handles version conflicts, build errors, and platform issues automatically.",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # ── peep install ──────────────────────────────────────────────────────────
+    install_parser = subparsers.add_parser("install", help="Install one or more packages")
+    install_parser.add_argument("packages", nargs="+", help="Package(s) to install, e.g. requests or requests==2.28.0")
+    install_parser.add_argument("-v", "--verbose", action="store_true", help="Show detailed output")
+    install_parser.add_argument("--force", action="store_true", help="Force reinstall even if already installed")
+
+    # ── peep check ───────────────────────────────────────────────────────────
+    check_parser = subparsers.add_parser("check", help="Check a package for compatibility without installing")
+    check_parser.add_argument("package", help="Package to check")
+    check_parser.add_argument("-v", "--verbose", action="store_true")
+
+    args = parser.parse_args()
+
+    if args.command == "install":
+        _handle_install(args)
+    elif args.command == "check":
+        _handle_check(args)
+
+
+def _handle_install(args):
+    # Parse packages — support both `requests` and `requests==2.28.0`
+    parsed = [_parse_package_arg(p) for p in args.packages]
+
+    if len(parsed) == 1:
+        name, version = parsed[0]
+        _print_status(f"Installing {name}" + (f"=={version}" if version else "") + "...")
+        report = install(name, version=version, verbose=args.verbose)
+        _print_report(report)
+    else:
+        _print_status(f"Installing {len(parsed)} packages...")
+        reports = install_many([p for p, _ in parsed], verbose=args.verbose)
+        for report in reports:
+            _print_report(report)
+
+    # Exit with error code if any install failed
+    if isinstance(reports if len(parsed) > 1 else [report], list):
+        results = reports if len(parsed) > 1 else [report]
+        if any(not r["success"] for r in results):
+            sys.exit(1)
+
+
+def _handle_check(args):
+    from .environment import check_python_compatibility, check_platform_compatibility
+    from .resolver import resolve_conflicts
+
+    name, version = _parse_package_arg(args.package)
+    _print_status(f"Checking {name}" + (f"=={version}" if version else "") + "...")
+
+    py = check_python_compatibility(name, version)
+    plat = check_platform_compatibility(name, version)
+    deps = resolve_conflicts(name, version)
+
+    print()
+    _section("Python compatibility")
+    if py.get("compatible") is True:
+        _ok(f"Compatible with Python {py.get('current_python')}")
+    elif py.get("compatible") is False:
+        _warn(f"Requires Python {py.get('requires_python')}, you have {py.get('current_python')}")
+        if py.get("suggested_version"):
+            _info(f"Suggested version: {name}=={py['suggested_version']}")
+    else:
+        _info("Could not determine Python compatibility")
+
+    _section("Platform compatibility")
+    if plat.get("has_compatible_wheel"):
+        _ok("Compatible wheel available for your platform")
+    elif plat.get("needs_compilation"):
+        _warn("No wheel available — package will be compiled from source")
+    elif not plat.get("has_sdist"):
+        _err("No compatible distribution found for your platform")
+
+    _section("Dependency conflicts")
+    if deps["clean"]:
+        _ok("No conflicts detected")
+    else:
+        for conflict in deps["conflicts"]:
+            _err(f"{conflict['package']} {conflict['installed']} installed, but {conflict['required']} required by {conflict['required_by']}")
+        for upgrade in deps["to_upgrade"]:
+            _warn(f"{upgrade['package']} will be upgraded {upgrade['from']} → {upgrade['to']}")
+
+
+def _print_report(report: dict):
+    pkg = report["package"]
+    ver = report.get("final_version")
+
+    print()
+    if report["success"]:
+        label = f"{pkg}=={ver}" if ver else pkg
+        _ok(f"Successfully installed {label}")
+    else:
+        _err(f"Failed to install {pkg}: {report.get('error', 'Unknown error')}")
+
+
+def _parse_package_arg(pkg_str: str) -> tuple[str, str | None]:
+    """Parse 'requests==2.28.0' into ('requests', '2.28.0'), or 'requests' into ('requests', None)."""
+    if "==" in pkg_str:
+        name, version = pkg_str.split("==", 1)
+        return name.strip(), version.strip()
+    return pkg_str.strip(), None
+
+
+# ── Terminal output helpers ────────────────────────────────────────────────────
+
+RESET  = "\033[0m"
+GREEN  = "\033[32m"
+YELLOW = "\033[33m"
+RED    = "\033[31m"
+CYAN   = "\033[36m"
+BOLD   = "\033[1m"
+
+def _print_status(msg): print(f"{BOLD}{CYAN}→ {msg}{RESET}")
+def _section(label):    print(f"\n{BOLD}{label}{RESET}")
+def _ok(msg):           print(f"  {GREEN}✔ {msg}{RESET}")
+def _warn(msg):         print(f"  {YELLOW}⚠ {msg}{RESET}")
+def _err(msg):          print(f"  {RED}✘ {msg}{RESET}")
+def _info(msg):         print(f"  {CYAN}ℹ {msg}{RESET}")

peep_install-0.1.0/peep/diagnostics.py

@@ -0,0 +1,181 @@
+import subprocess
+import sys
+import json
+
+
+def verify_install(package_name: str) -> dict:
+    """
+    Verify a package is actually importable after installation.
+    Runs in a subprocess to get a clean import environment.
+    Returns a result dict with importable, version, and error if any.
+    """
+    # Normalize package name to import name
+    import_name = _resolve_import_name(package_name)
+
+    probe = f"""
+import sys
+import json
+
+try:
+    mod = __import__("{import_name}")
+    version = getattr(mod, "__version__", None)
+    print(json.dumps({{"importable": True, "version": version}}))
+except ImportError as e:
+    print(json.dumps({{"importable": False, "error": str(e)}}))
+except Exception as e:
+    print(json.dumps({{"importable": False, "error": f"Unexpected error: {{e}}"}}))
+"""
+
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c", probe],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+
+        if result.returncode != 0 or not result.stdout.strip():
+            return {
+                "importable": False,
+                "error": result.stderr.strip() or "No output from import probe",
+            }
+
+        return json.loads(result.stdout.strip())
+
+    except subprocess.TimeoutExpired:
+        return {"importable": False, "error": "Import probe timed out after 15s"}
+    except json.JSONDecodeError:
+        return {"importable": False, "error": f"Could not parse probe output: {result.stdout.strip()}"}
+    except Exception as e:
+        return {"importable": False, "error": str(e)}
+
+
+def triage_import_failure(package_name: str) -> dict:
+    """
+    When verify_install fails, attempt to diagnose why.
+    Returns a diagnosis dict with cause and suggested fix.
+    """
+    import_name = _resolve_import_name(package_name)
+
+    checks = {
+        "missing_entirely": _check_missing(package_name),
+        "wrong_python": _check_wrong_python(package_name),
+        "broken_deps": _check_broken_deps(package_name),
+        "c_extension_broken": _check_c_extension(import_name),
+    }
+
+    # Determine the most likely cause
+    if checks["missing_entirely"]:
+        cause = "Package is not installed at all"
+        fix = f"peep install {package_name}"
+    elif checks["wrong_python"]:
+        cause = "Package was installed for a different Python interpreter"
+        fix = f"peep install {package_name}  (ensure you're using the right python)"
+    elif checks["broken_deps"]:
+        cause = f"Missing or broken dependencies: {checks['broken_deps']}"
+        fix = f"peep install {package_name} --force"
+    elif checks["c_extension_broken"]:
+        cause = "C extension failed to load (likely a build or ABI issue)"
+        fix = f"peep install {package_name} --force --no-binary"
+    else:
+        cause = "Unknown import failure"
+        fix = f"peep install {package_name} --force"
+
+    return {
+        "package": package_name,
+        "cause": cause,
+        "suggested_fix": fix,
+        "checks": checks,
+    }
+
+
+def _check_missing(package_name: str) -> bool:
+    """Check if the package shows up in pip list at all."""
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "show", package_name],
+        capture_output=True, text=True
+    )
+    return result.returncode != 0
+
+
+def _check_wrong_python(package_name: str) -> bool:
+    """
+    Check if the package is installed but under a different Python.
+    Detects the common case of pip vs pip3 confusion.
+    """
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "show", package_name],
+        capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        return False
+
+    # Check if the install location is within the current sys.prefix
+    for line in result.stdout.splitlines():
+        if line.startswith("Location:"):
+            location = line.split(":", 1)[1].strip()
+            return sys.prefix.lower() not in location.lower()
+
+    return False
+
+
+def _check_broken_deps(package_name: str) -> list[str] | None:
+    """Use pip check to find broken dependencies."""
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "check"],
+        capture_output=True, text=True
+    )
+    if result.returncode == 0:
+        return None
+
+    # Filter output to lines mentioning this package
+    broken = [
+        line for line in result.stdout.splitlines()
+        if package_name.lower() in line.lower()
+    ]
+    return broken if broken else None
+
+
+def _check_c_extension(import_name: str) -> bool:
+    """Check if the failure is specifically from a C extension load error."""
+    probe = f"""
+try:
+    __import__("{import_name}")
+except ImportError as e:
+    print("c_ext" if "cannot import" in str(e).lower() or ".so" in str(e) else "other")
+except Exception:
+    print("other")
+else:
+    print("ok")
+"""
+    result = subprocess.run(
+        [sys.executable, "-c", probe],
+        capture_output=True, text=True,
+        timeout=10,
+    )
+    return result.stdout.strip() == "c_ext"
+
+
+# Map of PyPI package names that differ from their import names
+_IMPORT_NAME_MAP = {
+    "pillow": "PIL",
+    "opencv-python": "cv2",
+    "opencv-python-headless": "cv2",
+    "scikit-learn": "sklearn",
+    "scikit-image": "skimage",
+    "beautifulsoup4": "bs4",
+    "pyyaml": "yaml",
+    "python-dateutil": "dateutil",
+    "python-dotenv": "dotenv",
+    "pyzmq": "zmq",
+    "pygments": "pygments",
+    "typing-extensions": "typing_extensions",
+    "attrs": "attr",
+    "moviepy": "moviepy.editor",
+}
+
+
+def _resolve_import_name(package_name: str) -> str:
+    """Resolve PyPI package name to its actual Python import name."""
+    normalized = package_name.lower().strip()
+    return _IMPORT_NAME_MAP.get(normalized, normalized.replace("-", "_"))

peep_install-0.1.0/peep/environment.py

@@ -0,0 +1,168 @@
+import sys
+import platform
+import sysconfig
+import requests
+from packaging.version import Version
+from packaging.specifiers import SpecifierSet
+
+
+def get_current_environment() -> dict:
+    """Snapshot of the current Python + platform environment."""
+    return {
+        "python_version": Version(platform.python_version()),
+        "platform_system": platform.system().lower(),       # 'linux', 'windows', 'darwin'
+        "platform_machine": platform.machine().lower(),     # 'x86_64', 'arm64', etc.
+        "platform_tags": _get_platform_tags(),
+    }
+
+
+def _get_platform_tags() -> list[str]:
+    """Get the list of compatible wheel platform tags for this system."""
+    try:
+        from pip._internal.utils.compatibility_tags import get_supported
+        return [str(tag) for tag in get_supported()]
+    except ImportError:
+        # Fallback: construct basic tags manually
+        py = f"cp{sys.version_info.major}{sys.version_info.minor}"
+        arch = sysconfig.get_platform().replace("-", "_").replace(".", "_")
+        return [f"{py}-{py}-{arch}", f"py3-none-any", f"py{sys.version_info.major}-none-any"]
+
+
+def fetch_package_metadata(package_name: str, version: str = None) -> dict | None:
+    """Fetch package metadata from PyPI JSON API."""
+    url = f"https://pypi.org/pypi/{package_name}/json"
+    if version:
+        url = f"https://pypi.org/pypi/{package_name}/{version}/json"
+
+    try:
+        resp = requests.get(url, timeout=10)
+        resp.raise_for_status()
+        return resp.json()
+    except requests.RequestException:
+        return None
+
+
+def check_python_compatibility(package_name: str, version: str = None) -> dict:
+    """
+    Check if a package is compatible with the current Python version.
+    Returns a result dict with 'compatible', 'requires_python', and optionally 'suggested_version'.
+    """
+    env = get_current_environment()
+    metadata = fetch_package_metadata(package_name, version)
+
+    if metadata is None:
+        return {"compatible": None, "error": f"Could not fetch metadata for '{package_name}'"}
+
+    info = metadata["info"]
+    requires_python = info.get("requires_python")
+
+    if not requires_python:
+        return {"compatible": True, "requires_python": None}
+
+    spec = SpecifierSet(requires_python)
+    compatible = env["python_version"] in spec
+
+    result = {
+        "compatible": compatible,
+        "requires_python": requires_python,
+        "current_python": str(env["python_version"]),
+    }
+
+    if not compatible:
+        # Try to find the latest version that does support this Python
+        suggested = _find_compatible_version(metadata["releases"], spec, env["python_version"])
+        result["suggested_version"] = suggested
+
+    return result
+
+
+def _find_compatible_version(releases: dict, broken_spec: SpecifierSet, current_python: Version) -> str | None:
+    """
+    Walk all available releases and return the latest one compatible
+    with the current Python version.
+    """
+    candidates = []
+
+    for ver_str, files in releases.items():
+        if not files:
+            continue
+        try:
+            v = Version(ver_str)
+        except Exception:
+            continue
+
+        # Check each release file for its requires_python
+        for f in files:
+            rp = f.get("requires_python")
+            if rp is None:
+                candidates.append(v)
+                break
+            try:
+                if current_python in SpecifierSet(rp):
+                    candidates.append(v)
+                    break
+            except Exception:
+                continue
+
+    if not candidates:
+        return None
+
+    return str(max(candidates))
+
+
+def check_platform_compatibility(package_name: str, version: str = None) -> dict:
+    """
+    Check if any wheel for this package supports the current platform.
+    Falls back to sdist detection if no compatible wheel is found.
+    """
+    env = get_current_environment()
+    metadata = fetch_package_metadata(package_name, version)
+
+    if metadata is None:
+        return {"compatible": None, "error": f"Could not fetch metadata for '{package_name}'"}
+
+    target_version = version or metadata["info"]["version"]
+    release_files = metadata["releases"].get(target_version, [])
+
+    has_sdist = False
+    has_compatible_wheel = False
+    has_any_wheel = False
+
+    for f in release_files:
+        if f["packagetype"] == "sdist":
+            has_sdist = True
+        elif f["packagetype"] == "bdist_wheel":
+            has_any_wheel = True
+            filename = f["filename"]
+            # Check platform tag compatibility
+            if _wheel_is_compatible(filename, env["platform_tags"]):
+                has_compatible_wheel = True
+
+    return {
+        "has_compatible_wheel": has_compatible_wheel,
+        "has_sdist": has_sdist,
+        "has_any_wheel": has_any_wheel,
+        "needs_compilation": has_sdist and not has_compatible_wheel,
+        "platform": env["platform_system"],
+        "machine": env["platform_machine"],
+    }
+
+
+def _wheel_is_compatible(filename: str, supported_tags: list[str]) -> bool:
+    """Check if a wheel filename's tags match any of the supported platform tags."""
+    # Wheel filename format: {name}-{version}(-{build})?-{python}-{abi}-{platform}.whl
+    try:
+        base = filename.replace(".whl", "")
+        parts = base.split("-")
+        if len(parts) < 5:
+            return False
+        py_tag, abi_tag, plat_tag = parts[-3], parts[-2], parts[-1]
+        wheel_tag = f"{py_tag}-{abi_tag}-{plat_tag}"
+
+        # Pure Python wheels are always compatible
+        if "none-any" in wheel_tag:
+            return True
+
+        return wheel_tag in supported_tags
+    except Exception:
+        return False

peep_install-0.1.0/peep/installer.py

@@ -0,0 +1,123 @@
+import subprocess
+import sys
+from .environment import check_python_compatibility, check_platform_compatibility
+from .resolver import resolve_conflicts
+from .build import check_and_fix_build_deps
+from .diagnostics import verify_install
+
+
+def install(package: str, version: str = None, verbose: bool = False) -> dict:
+    """
+    Full peep install pipeline for a single package.
+    Runs all checks, auto-fixes what it can, then delegates to pip.
+    Returns a full report of what happened.
+    """
+    report = {
+        "package": package,
+        "version": version,
+        "steps": {},
+        "success": False,
+        "final_version": None,
+    }
+
+    target = f"{package}=={version}" if version else package
+    resolved_version = version  # May be updated by compatibility checks
+
+    # ── Step 1: Python version compatibility ─────────────────────────────────
+    py_check = check_python_compatibility(package, version)
+    report["steps"]["python_compatibility"] = py_check
+
+    if py_check.get("compatible") is False:
+        suggested = py_check.get("suggested_version")
+        if suggested:
+            resolved_version = suggested
+            target = f"{package}=={suggested}"
+            report["steps"]["python_compatibility"]["action"] = f"Switched to {package}=={suggested}"
+        else:
+            report["error"] = f"{package} has no version compatible with Python {py_check['current_python']}"
+            return report
+
+    # ── Step 2: Platform compatibility ───────────────────────────────────────
+    plat_check = check_platform_compatibility(package, resolved_version)
+    report["steps"]["platform_compatibility"] = plat_check
+
+    needs_compilation = plat_check.get("needs_compilation", False)
+
+    if not plat_check.get("has_compatible_wheel") and not plat_check.get("has_sdist"):
+        report["error"] = f"No compatible distribution found for {package} on {plat_check.get('platform')}/{plat_check.get('machine')}"
+        return report
+
+    # ── Step 3: Dependency conflict resolution ────────────────────────────────
+    conflict_check = resolve_conflicts(package, resolved_version)
+    report["steps"]["dependency_resolution"] = conflict_check
+
+    if not conflict_check["clean"]:
+        report["error"] = f"Unresolvable dependency conflicts for {package}: {conflict_check['conflicts']}"
+        return report
+
+    # Silently pre-install or upgrade conflicting deps before the main package
+    for dep in conflict_check["to_install"] + conflict_check["to_upgrade"]:
+        dep_target = f"{dep['package']}=={dep.get('version') or dep.get('to')}" if dep.get("version") or dep.get("to") else dep["package"]
+        _run_pip(["install", dep_target], verbose=verbose)
+
+    # ── Step 4: Build dependency check + fix ─────────────────────────────────
+    build_check = check_and_fix_build_deps(package, needs_compilation)
+    report["steps"]["build_deps"] = build_check
+
+    if build_check.get("failed"):
+        hints = [f["hint"] for f in build_check["failed"] if f.get("hint")]
+        report["error"] = (
+            f"Could not auto-install build dependencies: "
+            f"{[f['dep'] for f in build_check['failed']]}. "
+            f"Manual steps: {hints}"
+        )
+        return report
+
+    # ── Step 5: Run pip ───────────────────────────────────────────────────────
+    pip_result = _run_pip(["install", target], verbose=verbose)
+    report["steps"]["pip"] = pip_result
+
+    if pip_result["returncode"] != 0:
+        # One retry: let pip attempt its own conflict resolution
+        retry_result = _run_pip(["install", target, "--upgrade"], verbose=verbose)
+        report["steps"]["pip_retry"] = retry_result
+
+        if retry_result["returncode"] != 0:
+            report["error"] = f"pip failed:\n{retry_result['stderr']}"
+            return report
+
+    # ── Step 6: Post-install verification ─────────────────────────────────────
+    verify = verify_install(package)
+    report["steps"]["verification"] = verify
+
+    if not verify["importable"]:
+        report["error"] = f"Package installed but failed to import: {verify.get('error')}"
+        return report
+
+    report["success"] = True
+    report["final_version"] = verify.get("version") or resolved_version
+    return report
+
+
+def install_many(packages: list[str], verbose: bool = False) -> list[dict]:
+    """Install multiple packages, collecting a report for each."""
+    return [install(pkg, verbose=verbose) for pkg in packages]
+
+
+def _run_pip(args: list[str], verbose: bool = False) -> dict:
+    """Shell out to pip with the given args. Returns returncode, stdout, stderr."""
+    cmd = [sys.executable, "-m", "pip"] + args
+
+    if not verbose:
+        args_with_quiet = cmd + ["-q"]
+    else:
+        args_with_quiet = cmd
+
+    result = subprocess.run(args_with_quiet, capture_output=True, text=True)
+
+    return {
+        "command": " ".join(args_with_quiet),
+        "returncode": result.returncode,
+        "stdout": result.stdout.strip(),
+        "stderr": result.stderr.strip(),
+    }

peep_install-0.1.0/peep/resolver.py

@@ -0,0 +1,131 @@
+import subprocess
+import sys
+from packaging.version import Version
+from packaging.specifiers import SpecifierSet
+from packaging.requirements import Requirement
+from .environment import fetch_package_metadata
+
+
+def get_installed_packages() -> dict[str, Version]:
+    """Return a dict of {package_name: installed_version} for the current environment."""
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "list", "--format=freeze"],
+            capture_output=True, text=True
+        )
+        packages = {}
+        for line in result.stdout.splitlines():
+            if "==" in line:
+                name, ver = line.split("==", 1)
+                try:
+                    packages[name.lower().strip()] = Version(ver.strip())
+                except Exception:
+                    continue
+        return packages
+    except Exception:
+        return {}
+
+
+def fetch_dependencies(package_name: str, version: str = None) -> list[Requirement]:
+    """Fetch the dependency list for a package from PyPI metadata."""
+    metadata = fetch_package_metadata(package_name, version)
+    if not metadata:
+        return []
+
+    requires_dist = metadata["info"].get("requires_dist") or []
+    deps = []
+
+    for dep_str in requires_dist:
+        try:
+            req = Requirement(dep_str)
+            # Skip extras/optional dependencies (e.g. dev, test, docs)
+            if not req.marker or req.marker.evaluate({"extra": ""}):
+                deps.append(req)
+        except Exception:
+            continue
+
+    return deps
+
+
+def get_all_versions(package_name: str) -> list[Version]:
+    """Fetch all available versions of a package from PyPI."""
+    metadata = fetch_package_metadata(package_name)
+    if not metadata:
+        return []
+
+    versions = []
+    for ver_str in metadata["releases"].keys():
+        try:
+            versions.append(Version(ver_str))
+        except Exception:
+            continue
+
+    return sorted(versions, reverse=True)
+
+
+def resolve_conflicts(package_name: str, requested_version: str = None) -> dict:
+    """
+    Check the full dependency tree of a package against the current environment.
+    Returns a resolution plan: what to install, what to upgrade, what conflicts exist.
+    """
+    installed = get_installed_packages()
+    deps = fetch_dependencies(package_name, requested_version)
+
+    to_install = []
+    to_upgrade = []
+    conflicts = []
+
+    for req in deps:
+        name = req.name.lower()
+        specifier = req.specifier  # e.g. SpecifierSet(">=1.0,<2.0")
+
+        if name not in installed:
+            # Not installed at all — find best version to install
+            best = _best_version(name, specifier)
+            to_install.append({"package": req.name, "version": str(best) if best else None, "reason": "not installed"})
+
+        else:
+            current = installed[name]
+            if current in specifier:
+                # Already installed and compatible — nothing to do
+                continue
+            else:
+                # Installed but wrong version
+                best = _best_version(name, specifier)
+                if best:
+                    to_upgrade.append({
+                        "package": req.name,
+                        "from": str(current),
+                        "to": str(best),
+                        "required_by": package_name,
+                        "specifier": str(specifier),
+                    })
+                else:
+                    conflicts.append({
+                        "package": req.name,
+                        "installed": str(current),
+                        "required": str(specifier),
+                        "required_by": package_name,
+                        "resolvable": False,
+                    })
+
+    return {
+        "package": package_name,
+        "version": requested_version,
+        "to_install": to_install,
+        "to_upgrade": to_upgrade,
+        "conflicts": conflicts,
+        "clean": len(conflicts) == 0,
+    }
+
+
+def _best_version(package_name: str, specifier: SpecifierSet) -> Version | None:
+    """Find the latest version of a package that satisfies the given specifier."""
+    versions = get_all_versions(package_name)
+    for v in versions:
+        # Skip pre-releases unless specifier explicitly allows them
+        if v.is_prerelease:
+            continue
+        if v in specifier:
+            return v
+    return None

peep_install-0.1.0/peep_install.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: peep-install
+Version: 0.1.0
+Summary: A smarter pip that auto-resolves version conflicts, build errors, and platform issues
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.28.0
+Requires-Dist: packaging>=23.0

peep_install-0.1.0/peep_install.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+pyproject.toml
+peep/__init__.py
+peep/build.py
+peep/cli.py
+peep/diagnostics.py
+peep/environment.py
+peep/installer.py
+peep/resolver.py
+peep_install.egg-info/PKG-INFO
+peep_install.egg-info/SOURCES.txt
+peep_install.egg-info/dependency_links.txt
+peep_install.egg-info/entry_points.txt
+peep_install.egg-info/requires.txt
+peep_install.egg-info/top_level.txt

peep_install-0.1.0/peep_install.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

peep_install-0.1.0/peep_install.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+peep = peep.cli:main

peep_install-0.1.0/peep_install.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.28.0
+packaging>=23.0

peep_install-0.1.0/peep_install.egg-info/top_level.txt

@@ -0,0 +1 @@
+peep

peep_install-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "peep-install"
+version = "0.1.0"
+description = "A smarter pip that auto-resolves version conflicts, build errors, and platform issues"
+requires-python = ">=3.9"
+dependencies = [
+    "requests>=2.28.0",
+    "packaging>=23.0",
+]
+
+[project.scripts]
+peep = "peep.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["peep*"]

peep_install-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+