clang-tool-chain 1.0.3__py3-none-any.whl

clang_tool_chain/fetch.py

@@ -0,0 +1,158 @@
+"""
+CLI tool for fetching clang toolchain binaries.
+
+This module provides a command-line interface for downloading and installing
+the LLVM/Clang toolchain binaries.
+"""
+
+import argparse
+import sys
+from dataclasses import dataclass
+
+from . import downloader, wrapper
+
+
+@dataclass
+class FetchConfig:
+    """Configuration for fetching toolchain binaries."""
+
+    platform: str | None
+    arch: str | None
+    output_dir: str | None
+    verbose: bool
+
+
+def parse_args() -> FetchConfig:
+    """
+    Parse command-line arguments.
+
+    Returns:
+        FetchConfig dataclass with parsed arguments
+    """
+    parser = argparse.ArgumentParser(
+        description="Fetch and install clang-tool-chain binaries",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Download for current platform
+  clang-tool-chain-fetch
+
+  # Download for specific platform (verbose)
+  clang-tool-chain-fetch --platform win --arch x86_64 --verbose
+
+  # Download to custom directory
+  clang-tool-chain-fetch --output-dir /custom/path --verbose
+
+Environment Variables:
+  CLANG_TOOL_CHAIN_DOWNLOAD_PATH  Override default download path (~/.clang-tool-chain)
+        """,
+    )
+
+    parser.add_argument(
+        "--platform",
+        choices=["win", "linux", "darwin"],
+        help="Target platform (default: current platform)",
+    )
+
+    parser.add_argument(
+        "--arch",
+        choices=["x86_64", "arm64"],
+        help="Target architecture (required if --platform is specified, default: current arch)",
+    )
+
+    parser.add_argument(
+        "--output-dir",
+        metavar="PATH",
+        help="Output directory for downloads (overrides CLANG_TOOL_CHAIN_DOWNLOAD_PATH)",
+    )
+
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Show detailed progress information",
+    )
+
+    args = parser.parse_args()
+
+    # Validate platform/arch combination
+    if args.platform and not args.arch:
+        parser.error("--arch is required when --platform is specified")
+
+    return FetchConfig(
+        platform=args.platform,
+        arch=args.arch,
+        output_dir=args.output_dir,
+        verbose=args.verbose,
+    )
+
+
+def main() -> int:
+    """
+    Main entry point for clang-tool-chain-fetch.
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    try:
+        config = parse_args()
+
+        # Determine platform and arch
+        if config.platform and config.arch:
+            platform = config.platform
+            arch = config.arch
+        else:
+            # Auto-detect current platform
+            platform, arch = wrapper.get_platform_info()
+
+        if config.verbose:
+            print(f"Platform: {platform}")
+            print(f"Architecture: {arch}")
+
+        # Set output directory if specified
+        if config.output_dir:
+            import os
+
+            os.environ["CLANG_TOOL_CHAIN_DOWNLOAD_PATH"] = config.output_dir
+            if config.verbose:
+                print(f"Output directory: {config.output_dir}")
+
+        # Download and install
+        downloader.ensure_toolchain(platform, arch)
+
+        # Check if download happened or was already installed
+        if downloader.is_toolchain_installed(platform, arch):
+            install_dir = downloader.get_install_dir(platform, arch)
+            bin_dir = install_dir / "bin"
+
+            if config.verbose or not downloader.is_toolchain_installed(platform, arch):
+                print("\nToolchain installed successfully!")
+                print(f"Install directory: {install_dir}")
+                print(f"Binary directory: {bin_dir}")
+
+                # Count binaries
+                if bin_dir.exists():
+                    bin_count = len(list(bin_dir.iterdir()))
+                    print(f"Binaries available: {bin_count}")
+            else:
+                print(f"Toolchain already installed at: {install_dir}")
+
+            return 0
+        else:
+            print("ERROR: Toolchain installation failed", file=sys.stderr)
+            return 1
+
+    except KeyboardInterrupt:
+        print("\nInterrupted by user", file=sys.stderr)
+        return 130
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        if "--verbose" in sys.argv or "-v" in sys.argv:
+            import traceback
+
+            traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

clang_tool_chain/paths.py

@@ -0,0 +1,93 @@
+"""
+CLI tool for displaying paths to installed toolchain binaries.
+
+This module provides a command-line interface for listing all installed
+toolchain binary paths in JSON format.
+"""
+
+import json
+import sys
+
+from . import downloader, wrapper
+
+
+def main() -> int:
+    """
+    Main entry point for clang-tool-chain-paths.
+
+    Outputs JSON with paths to all installed tools.
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    try:
+        # Get current platform info
+        platform, arch = wrapper.get_platform_info()
+
+        # Check if toolchain is installed
+        if not downloader.is_toolchain_installed(platform, arch):
+            result = {
+                "error": "Toolchain not installed",
+                "platform": platform,
+                "arch": arch,
+                "installed": False,
+                "install_dir": None,
+                "bin_dir": None,
+                "tools": {},
+            }
+            print(json.dumps(result, indent=2))
+            return 1
+
+        # Get installation directories
+        install_dir = downloader.get_install_dir(platform, arch)
+        bin_dir = install_dir / "bin"
+
+        if not bin_dir.exists():
+            result = {
+                "error": "Binary directory not found",
+                "platform": platform,
+                "arch": arch,
+                "installed": True,
+                "install_dir": str(install_dir),
+                "bin_dir": str(bin_dir),
+                "tools": {},
+            }
+            print(json.dumps(result, indent=2))
+            return 1
+
+        # Enumerate all tools in bin directory
+        tools = {}
+        for binary_path in sorted(bin_dir.iterdir()):
+            if binary_path.is_file():
+                tool_name = binary_path.stem  # Remove .exe on Windows
+                tools[tool_name] = str(binary_path)
+
+        # Build result
+        result = {
+            "platform": platform,
+            "arch": arch,
+            "installed": True,
+            "install_dir": str(install_dir),
+            "bin_dir": str(bin_dir),
+            "tool_count": len(tools),
+            "tools": tools,
+        }
+
+        # Output as JSON
+        print(json.dumps(result, indent=2))
+        return 0
+
+    except KeyboardInterrupt:
+        print("\nInterrupted by user", file=sys.stderr)
+        return 130
+    except Exception as e:
+        result = {
+            "error": str(e),
+            "installed": False,
+        }
+        print(json.dumps(result, indent=2))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

clang_tool_chain/sccache_runner.py

@@ -0,0 +1,160 @@
+"""
+sccache runner using iso-env for isolated execution.
+
+This module provides fallback functionality to run sccache via iso-env
+when sccache is not found in the system PATH.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_sccache_path() -> str | None:
+    """
+    Get the path to sccache executable.
+
+    Returns:
+        Path to sccache if found in PATH, None otherwise.
+    """
+    return shutil.which("sccache")
+
+
+def get_iso_env_cache_dir() -> Path:
+    """
+    Get the cache directory for iso-env sccache installation.
+
+    Returns:
+        Path to the cache directory.
+    """
+    # Use the same directory as clang-tool-chain for consistency
+    base_dir = os.environ.get("CLANG_TOOL_CHAIN_DOWNLOAD_PATH")
+    cache_dir = Path(base_dir) / "sccache-env" if base_dir else Path.home() / ".clang-tool-chain" / "sccache-env"
+
+    return cache_dir
+
+
+def run_sccache_via_isoenv(args: list[str]) -> int:
+    """
+    Run sccache via iso-env in an isolated environment.
+
+    Args:
+        args: Command-line arguments to pass to sccache
+
+    Returns:
+        Exit code from sccache execution
+    """
+    try:
+        from iso_env import IsoEnv, IsoEnvArgs, Requirements
+    except ImportError:
+        print("=" * 70, file=sys.stderr)
+        print("ERROR: iso-env package not found", file=sys.stderr)
+        print("=" * 70, file=sys.stderr)
+        print(file=sys.stderr)
+        print("iso-env is required as a fallback when sccache is not in PATH.", file=sys.stderr)
+        print("Please install it with:", file=sys.stderr)
+        print("  pip install clang-tool-chain", file=sys.stderr)
+        print(file=sys.stderr)
+        print("Or install sccache directly:", file=sys.stderr)
+        print("  pip install clang-tool-chain[sccache]", file=sys.stderr)
+        print(file=sys.stderr)
+        print("=" * 70, file=sys.stderr)
+        return 1
+
+    cache_dir = get_iso_env_cache_dir()
+
+    # Create iso-env configuration for sccache
+    try:
+        # First time setup - create the environment
+        print(f"Setting up isolated sccache environment at {cache_dir}...", file=sys.stderr)
+
+        # Create requirements for sccache
+        requirements_txt = "sccache>=0.7.0\n"
+        requirements = Requirements(requirements_txt)
+
+        # Create IsoEnvArgs
+        iso_args = IsoEnvArgs(venv_path=cache_dir, build_info=requirements)
+
+        # Create IsoEnv instance
+        env = IsoEnv(iso_args)
+
+        # Run sccache with the provided arguments
+        result = env.run(["sccache"] + args)
+
+        return result.returncode if result.returncode is not None else 0
+
+    except Exception as e:
+        print("=" * 70, file=sys.stderr)
+        print("ERROR: Failed to run sccache via iso-env", file=sys.stderr)
+        print("=" * 70, file=sys.stderr)
+        print(file=sys.stderr)
+        print(f"Error details: {e}", file=sys.stderr)
+        print(file=sys.stderr)
+        print("You may want to install sccache directly:", file=sys.stderr)
+        print("  pip install clang-tool-chain[sccache]", file=sys.stderr)
+        print("  cargo install sccache", file=sys.stderr)
+        print("  # or use your system package manager", file=sys.stderr)
+        print(file=sys.stderr)
+        print("=" * 70, file=sys.stderr)
+        return 1
+
+
+def run_sccache(args: list[str]) -> int:
+    """
+    Run sccache, using iso-env as fallback if not found in PATH.
+
+    Args:
+        args: Command-line arguments to pass to sccache
+
+    Returns:
+        Exit code from sccache execution
+    """
+    sccache_path = get_sccache_path()
+
+    if sccache_path:
+        # sccache found in PATH, use it directly
+        cmd = [sccache_path] + args
+
+        try:
+            result = subprocess.run(cmd)
+            return result.returncode
+        except Exception as e:
+            print(f"ERROR: Failed to execute sccache: {e}", file=sys.stderr)
+            return 1
+    else:
+        # sccache not found in PATH, use iso-env fallback
+        print("sccache not found in PATH, using isolated environment...", file=sys.stderr)
+        print(file=sys.stderr)
+        return run_sccache_via_isoenv(args)
+
+
+def run_sccache_with_compiler(compiler_path: str, args: list[str]) -> int:
+    """
+    Run sccache with a compiler, using iso-env as fallback if sccache not found in PATH.
+
+    Args:
+        compiler_path: Path to the compiler executable
+        args: Command-line arguments to pass to the compiler
+
+    Returns:
+        Exit code from sccache execution
+    """
+    sccache_path = get_sccache_path()
+
+    if sccache_path:
+        # sccache found in PATH, use it directly
+        cmd = [sccache_path, compiler_path] + args
+
+        try:
+            result = subprocess.run(cmd)
+            return result.returncode
+        except Exception as e:
+            print(f"ERROR: Failed to execute sccache: {e}", file=sys.stderr)
+            return 1
+    else:
+        # sccache not found in PATH, use iso-env fallback
+        print("sccache not found in PATH, using isolated environment...", file=sys.stderr)
+        print(file=sys.stderr)
+        return run_sccache_via_isoenv([compiler_path] + args)