uv-sbom-bin 0.1.0__py3-none-any.whl

uv_sbom_bin/__init__.py

@@ -0,0 +1,7 @@
+"""Python wrapper for uv-sbom CLI tool."""
+
+__version__ = "0.1.0"
+
+from .install import ensure_binary, get_binary_path
+
+__all__ = ["ensure_binary", "get_binary_path", "__version__"]

uv_sbom_bin/__main__.py

@@ -0,0 +1,30 @@
+"""CLI entry point for uv-sbom."""
+
+import subprocess
+import sys
+
+from .install import ensure_binary
+
+
+def main():
+    """Main entry point that ensures binary is installed and runs it."""
+    try:
+        binary_path = ensure_binary()
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    # Run the binary with all arguments passed through
+    try:
+        result = subprocess.run(
+            [str(binary_path)] + sys.argv[1:],
+            check=False
+        )
+        return result.returncode
+    except Exception as e:
+        print(f"Error running uv-sbom: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

uv_sbom_bin/install.py

@@ -0,0 +1,196 @@
+"""Binary installation logic for uv-sbom."""
+
+import os
+import platform
+import sys
+import tarfile
+import zipfile
+from pathlib import Path
+from urllib.request import urlretrieve
+
+# Version of uv-sbom to install
+UV_SBOM_VERSION = "0.1.0"
+
+# GitHub release URL template
+RELEASE_URL_TEMPLATE = (
+    "https://github.com/Taketo-Yoda/uv-sbom/releases/download/"
+    "v{version}/uv-sbom-{platform}.{ext}"
+)
+
+
+def get_platform_info():
+    """Detect the current platform and return the appropriate binary info.
+
+    Returns:
+        tuple: (platform_string, file_extension)
+
+    Raises:
+        RuntimeError: If the platform is not supported
+    """
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    if system == "darwin":
+        if machine == "arm64":
+            return "aarch64-apple-darwin", "tar.gz"
+        elif machine == "x86_64":
+            return "x86_64-apple-darwin", "tar.gz"
+        else:
+            raise RuntimeError(f"Unsupported macOS architecture: {machine}")
+
+    elif system == "linux":
+        if machine == "x86_64":
+            return "x86_64-unknown-linux-gnu", "tar.gz"
+        else:
+            raise RuntimeError(
+                f"Unsupported Linux architecture: {machine}. "
+                "Only x86_64 is currently supported."
+            )
+
+    elif system == "windows":
+        if machine in ("amd64", "x86_64"):
+            return "x86_64-pc-windows-msvc", "zip"
+        else:
+            raise RuntimeError(f"Unsupported Windows architecture: {machine}")
+
+    else:
+        raise RuntimeError(f"Unsupported operating system: {system}")
+
+
+def get_binary_path():
+    """Get the path where the uv-sbom binary should be installed.
+
+    Returns:
+        Path: Path to the binary executable
+    """
+    package_dir = Path(__file__).parent
+    binary_dir = package_dir / "bin"
+
+    if platform.system().lower() == "windows":
+        return binary_dir / "uv-sbom.exe"
+    else:
+        return binary_dir / "uv-sbom"
+
+
+def download_binary(platform_str, extension, dest_dir):
+    """Download the binary archive for the current platform.
+
+    Args:
+        platform_str: Platform identifier (e.g., "x86_64-apple-darwin")
+        extension: File extension ("tar.gz" or "zip")
+        dest_dir: Destination directory for the download
+
+    Returns:
+        Path: Path to the downloaded archive
+    """
+    url = RELEASE_URL_TEMPLATE.format(
+        version=UV_SBOM_VERSION,
+        platform=platform_str,
+        ext=extension
+    )
+
+    archive_name = f"uv-sbom-{platform_str}.{extension}"
+    archive_path = dest_dir / archive_name
+
+    print(f"Downloading uv-sbom v{UV_SBOM_VERSION} for {platform_str}...")
+    print(f"URL: {url}")
+
+    try:
+        urlretrieve(url, archive_path)
+        print(f"Downloaded to {archive_path}")
+        return archive_path
+    except Exception as e:
+        raise RuntimeError(
+            f"Failed to download uv-sbom binary: {e}\n"
+            f"URL: {url}"
+        )
+
+
+def extract_binary(archive_path, dest_dir):
+    """Extract the binary from the downloaded archive.
+
+    Args:
+        archive_path: Path to the archive file
+        dest_dir: Destination directory for extraction
+    """
+    print(f"Extracting {archive_path}...")
+
+    if archive_path.suffix == ".zip" or archive_path.name.endswith(".zip"):
+        with zipfile.ZipFile(archive_path, 'r') as zip_ref:
+            zip_ref.extractall(dest_dir)
+    else:  # tar.gz
+        with tarfile.open(archive_path, 'r:gz') as tar_ref:
+            tar_ref.extractall(dest_dir)
+
+    print(f"Extracted to {dest_dir}")
+
+
+def make_executable(binary_path):
+    """Make the binary executable on Unix-like systems.
+
+    Args:
+        binary_path: Path to the binary file
+    """
+    if platform.system().lower() != "windows":
+        os.chmod(binary_path, 0o755)
+        print(f"Made {binary_path} executable")
+
+
+def ensure_binary():
+    """Ensure the uv-sbom binary is installed.
+
+    Downloads and installs the binary if not already present.
+
+    Returns:
+        Path: Path to the installed binary
+
+    Raises:
+        RuntimeError: If installation fails
+    """
+    binary_path = get_binary_path()
+
+    # Check if already installed
+    if binary_path.exists():
+        print(f"uv-sbom binary already installed at {binary_path}")
+        return binary_path
+
+    # Get platform info
+    try:
+        platform_str, extension = get_platform_info()
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        raise
+
+    # Create binary directory
+    binary_dir = binary_path.parent
+    binary_dir.mkdir(parents=True, exist_ok=True)
+
+    # Download and extract
+    try:
+        archive_path = download_binary(platform_str, extension, binary_dir)
+        extract_binary(archive_path, binary_dir)
+
+        # Verify the binary exists
+        if not binary_path.exists():
+            raise RuntimeError(
+                f"Binary not found after extraction: {binary_path}"
+            )
+
+        # Make executable
+        make_executable(binary_path)
+
+        # Clean up archive
+        archive_path.unlink()
+        print(f"Cleaned up {archive_path}")
+
+        print(f"✅ uv-sbom v{UV_SBOM_VERSION} installed successfully!")
+        return binary_path
+
+    except Exception as e:
+        print(f"❌ Installation failed: {e}", file=sys.stderr)
+        raise
+
+
+if __name__ == "__main__":
+    # Allow running as: python -m uv_sbom_bin.install
+    ensure_binary()

uv_sbom_bin-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: uv-sbom-bin
+Version: 0.1.0
+Summary: Python wrapper for uv-sbom - SBOM generation tool for uv projects
+Project-URL: Homepage, https://github.com/Taketo-Yoda/uv-sbom
+Project-URL: Repository, https://github.com/Taketo-Yoda/uv-sbom
+Project-URL: Bug Tracker, https://github.com/Taketo-Yoda/uv-sbom/issues
+Author-email: Taketo Yoda <exhaust7.drs@gmail.com>
+License: MIT
+Keywords: cyclonedx,python-wrapper,sbom,security,supply-chain,uv
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Software Distribution
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# uv-sbom-bin
+
+Python wrapper for the `uv-sbom` CLI tool written in Rust.
+
+This package allows Python users to install `uv-sbom` via PyPI and use it with `uv tool install`.
+
+## Installation
+
+### Via pip
+
+```bash
+pip install uv-sbom-bin
+```
+
+### Via uv
+
+```bash
+uv tool install uv-sbom-bin
+```
+
+## Usage
+
+After installation, the `uv-sbom` command will be available in your PATH:
+
+```bash
+uv-sbom --version
+uv-sbom --format json
+uv-sbom --format markdown --output SBOM.md
+```
+
+## How It Works
+
+This package downloads the prebuilt Rust binary for your platform from the [GitHub releases](https://github.com/Taketo-Yoda/uv-sbom/releases) and installs it.
+
+Supported platforms:
+- macOS (Apple Silicon and Intel)
+- Linux (x86_64)
+- Windows (x86_64)
+
+## Development
+
+This is a wrapper package. The actual tool is developed at:
+https://github.com/Taketo-Yoda/uv-sbom
+
+## License
+
+MIT License - see [LICENSE](https://github.com/Taketo-Yoda/uv-sbom/blob/main/LICENSE)

uv_sbom_bin-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+uv_sbom_bin/__init__.py,sha256=ADA4IPJMVYgQ1cc-yuWF-fB_Ehrp3ukr9zYxo4FJliU,182
+uv_sbom_bin/__main__.py,sha256=WhZJUeivXr7JnKsRwPKbEY_RQz2p9YrO5lOtcFRWtOU,696
+uv_sbom_bin/install.py,sha256=5PMo9wWQEMlFIF-OY17y1ZFV98rv8FsV3orL3jglxVQ,5417
+uv_sbom_bin-0.1.0.dist-info/METADATA,sha256=_Iy2cfv4oLTr1zk98hFn-bHhA9qubgR_d6ZmPGVBmCg,2105
+uv_sbom_bin-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+uv_sbom_bin-0.1.0.dist-info/entry_points.txt,sha256=h3xm_-qaiw_VpHnAUjf95X_Lpbf2Tm5g04U9ivqKLhA,54
+uv_sbom_bin-0.1.0.dist-info/RECORD,,

uv_sbom_bin-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

uv_sbom_bin-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+uv-sbom = uv_sbom_bin.__main__:main