gpu-stack-inspector 0.1.0__py3-none-any.whl

gpu_stack_inspector/runner.py

@@ -0,0 +1,273 @@
+"""Bounded, shell-free execution of diagnostic commands.
+
+Every external command the tool runs goes through a :class:`CommandRunner`, so that
+collectors can be tested with a fake one and the real one can enforce the same limits
+everywhere: an argument list (never a shell), a timeout, an output cap and no stdin.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import signal
+import subprocess
+import sys
+import threading
+import time
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+from typing import IO, Protocol
+
+from gpu_stack_inspector.models import FailureKind, ProbeFailure
+
+DEFAULT_MAX_OUTPUT = 256 * 1024
+"""Bytes kept per stream; diagnostic output larger than this is truncated."""
+
+_REAP_TIMEOUT = 2.0
+"""Seconds to wait for a finished command's pipes to close before giving up on them."""
+
+_CHUNK = 64 * 1024
+_DETAIL_LIMIT = 200
+
+
+class Outcome(StrEnum):
+    """How a command ended, as far as the runner can tell."""
+
+    OK = "ok"
+    NONZERO = "nonzero"
+    TIMEOUT = "timeout"
+    NOT_FOUND = "not_found"
+    PERMISSION = "permission"
+    OS_ERROR = "os_error"
+
+
+@dataclass(frozen=True, slots=True)
+class CommandResult:
+    """What a command printed and how it ended.
+
+    ``returncode`` is ``None`` when the command never started or was killed after a
+    timeout. ``error`` holds the operating system's message when it never started.
+    """
+
+    argv: tuple[str, ...]
+    outcome: Outcome
+    returncode: int | None = None
+    stdout: str = ""
+    stderr: str = ""
+    stdout_truncated: bool = False
+    stderr_truncated: bool = False
+    duration: float = 0.0
+    error: str = ""
+
+    @property
+    def ok(self) -> bool:
+        return self.outcome is Outcome.OK
+
+
+class CommandRunner(Protocol):
+    """Runs one command and reports the result; never raises for command failures."""
+
+    def run(
+        self,
+        argv: Sequence[str],
+        *,
+        timeout: float,
+        env_overrides: Mapping[str, str] | None = None,
+        cwd: Path | None = None,
+    ) -> CommandResult: ...
+
+
+_FAILURE_KINDS = {
+    Outcome.NOT_FOUND: FailureKind.NOT_FOUND,
+    Outcome.PERMISSION: FailureKind.PERMISSION_DENIED,
+    Outcome.TIMEOUT: FailureKind.TIMEOUT,
+    Outcome.NONZERO: FailureKind.NONZERO_EXIT,
+    Outcome.OS_ERROR: FailureKind.OS_ERROR,
+}
+
+
+def probe_failure(probe: str, result: CommandResult) -> ProbeFailure | None:
+    """Describe why ``result`` gave no usable output, or ``None`` if it succeeded.
+
+    The detail is short and meant for humans; it is redacted with the rest of the
+    snapshot before any output is written.
+    """
+    if result.ok:
+        return None
+    program = result.argv[0]
+    if result.outcome is Outcome.NOT_FOUND:
+        detail = f"{program} was not found"
+    elif result.outcome is Outcome.PERMISSION:
+        detail = f"permission denied when starting {program}"
+    elif result.outcome is Outcome.TIMEOUT:
+        detail = f"{program} did not finish within {result.duration:.1f} s and was stopped"
+    elif result.outcome is Outcome.NONZERO:
+        detail = f"{program} exited with code {result.returncode}"
+        # Some tools (nvidia-smi among them) print their errors on stdout.
+        first_line = _first_line(result.stderr) or _first_line(result.stdout)
+        if first_line:
+            detail += f": {first_line}"
+    else:
+        detail = f"{program} could not be started: {result.error}"
+    if len(detail) > _DETAIL_LIMIT:
+        detail = detail[: _DETAIL_LIMIT - 1] + "…"
+    return ProbeFailure(probe=probe, kind=_FAILURE_KINDS[result.outcome], detail=detail)
+
+
+def _first_line(text: str) -> str:
+    return next((line.strip() for line in text.splitlines() if line.strip()), "")
+
+
+class SubprocessRunner:
+    """The real runner: ``subprocess`` with an argument list, never a shell.
+
+    Each command runs in its own session (on POSIX), so a timeout or Ctrl+C kills the
+    command together with any children it started. Windows only kills the command itself.
+    """
+
+    def __init__(self, max_output: int = DEFAULT_MAX_OUTPUT) -> None:
+        if max_output <= 0:
+            raise ValueError("max_output must be positive")
+        self.max_output = max_output
+
+    def run(
+        self,
+        argv: Sequence[str],
+        *,
+        timeout: float,
+        env_overrides: Mapping[str, str] | None = None,
+        cwd: Path | None = None,
+    ) -> CommandResult:
+        args = _checked_argv(argv)
+        if timeout <= 0:
+            raise ValueError("timeout must be positive")
+        env = {**os.environ, **env_overrides} if env_overrides else None
+        started = time.monotonic()
+        try:
+            proc = subprocess.Popen(  # noqa: S603 - argument list without a shell
+                args,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env,
+                cwd=cwd,
+                start_new_session=sys.platform != "win32",
+            )
+        except FileNotFoundError as exc:
+            return _not_started(args, Outcome.NOT_FOUND, exc, started)
+        except PermissionError as exc:
+            return _not_started(args, Outcome.PERMISSION, exc, started)
+        except OSError as exc:
+            return _not_started(args, Outcome.OS_ERROR, exc, started)
+
+        if proc.stdout is None or proc.stderr is None:  # cannot happen with PIPE
+            raise RuntimeError("subprocess pipes were not created")
+        readers = (
+            _CappedReader(proc.stdout, self.max_output),
+            _CappedReader(proc.stderr, self.max_output),
+        )
+        for reader in readers:
+            reader.start()
+        timed_out = False
+        try:
+            try:
+                proc.wait(timeout=timeout)
+            except subprocess.TimeoutExpired:
+                timed_out = True
+                _kill(proc)
+                proc.wait()
+            # A child that escaped the process group may hold a pipe open; don't wait
+            # for it forever, keep what was read so far.
+            deadline = time.monotonic() + _REAP_TIMEOUT
+            for reader in readers:
+                reader.join(max(0.0, deadline - time.monotonic()))
+        except BaseException:
+            # Ctrl+C or an internal error: never leave the command running behind us,
+            # and reap it so it does not linger as a zombie.
+            _kill(proc)
+            with contextlib.suppress(subprocess.TimeoutExpired):
+                proc.wait(timeout=_REAP_TIMEOUT)
+            raise
+
+        out, err = readers
+        return CommandResult(
+            argv=args,
+            outcome=Outcome.TIMEOUT
+            if timed_out
+            else (Outcome.OK if proc.returncode == 0 else Outcome.NONZERO),
+            returncode=None if timed_out else proc.returncode,
+            stdout=_decode(out.data),
+            stderr=_decode(err.data),
+            stdout_truncated=out.truncated,
+            stderr_truncated=err.truncated,
+            duration=time.monotonic() - started,
+        )
+
+
+class _CappedReader(threading.Thread):
+    """Drains one pipe, keeping at most ``limit`` bytes.
+
+    It keeps reading (and discarding) past the limit so the command never blocks on a
+    full pipe.
+    """
+
+    def __init__(self, stream: IO[bytes], limit: int) -> None:
+        super().__init__(daemon=True)
+        self._stream = stream
+        self._limit = limit
+        self._kept = bytearray()
+        self.truncated = False
+
+    def run(self) -> None:
+        # os.read returns as soon as any bytes are available; a buffered read() would
+        # wait for a full chunk and lose the output of a command whose child keeps the
+        # pipe open.
+        fd = self._stream.fileno()
+        with contextlib.suppress(OSError, ValueError), self._stream:
+            while chunk := os.read(fd, _CHUNK):
+                room = self._limit - len(self._kept)
+                if room > 0:
+                    self._kept += chunk[:room]
+                if len(chunk) > room:
+                    self.truncated = True
+
+    @property
+    def data(self) -> bytes:
+        return bytes(self._kept)
+
+
+def _checked_argv(argv: Sequence[str]) -> tuple[str, ...]:
+    if isinstance(argv, str):
+        raise TypeError("argv must be a sequence of str, not a single command string")
+    args = tuple(argv)
+    if not args:
+        raise ValueError("argv is empty")
+    for arg in args:
+        if not isinstance(arg, str):
+            raise TypeError(f"argv items must be str, got {type(arg).__name__}")
+    return args
+
+
+def _not_started(
+    args: tuple[str, ...], outcome: Outcome, exc: OSError, started: float
+) -> CommandResult:
+    return CommandResult(
+        argv=args,
+        outcome=outcome,
+        error=exc.strerror or str(exc),
+        duration=time.monotonic() - started,
+    )
+
+
+def _kill(proc: subprocess.Popen[bytes]) -> None:
+    if sys.platform == "win32":
+        proc.kill()
+        return
+    with contextlib.suppress(ProcessLookupError, PermissionError):  # already gone
+        os.killpg(proc.pid, signal.SIGKILL)
+
+
+def _decode(data: bytes) -> str:
+    return data.decode("utf-8", errors="replace")

gpu_stack_inspector-0.1.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: gpu-stack-inspector
+Version: 0.1.0
+Summary: Explain why your AI code uses the GPU in one Python environment but not another.
+Keywords: cuda,pytorch,gpu,nvidia,conda,venv,diagnostics,troubleshooting
+Author: BhuwanJoshi-01
+Author-email: BhuwanJoshi-01 <bhuwanj779@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.27.3
+Requires-Python: >=3.11
+Project-URL: Homepage, https://bhuwanjoshi-01.github.io/gpu-stack-inspector/
+Project-URL: Documentation, https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/troubleshooting.md
+Project-URL: Source, https://github.com/BhuwanJoshi-01/gpu-stack-inspector
+Project-URL: Issues, https://github.com/BhuwanJoshi-01/gpu-stack-inspector/issues
+Project-URL: Changelog, https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# GPU Stack Inspector
+
+**Explain why your AI code uses the GPU in one Python environment but not another.**
+
+[![CI](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/actions/workflows/ci.yml/badge.svg)](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/LICENSE)
+[![Website](https://img.shields.io/badge/website-gpu--stack--inspector-17202e.svg)](https://bhuwanjoshi-01.github.io/gpu-stack-inspector/)
+
+`nvidia-smi` shows your GPU, yet `torch.cuda.is_available()` is `True` in one environment and `False` in another.
+GPU Stack Inspector inspects several Python interpreters from one command, shows what differs between them, and
+explains which difference matters, with the evidence:
+
+![compare on a laptop with an RTX 3050: a conda environment with torch 2.11.0+cu128 against a venv with torch 2.15.0+cpu. The table shows the torch build CUDA 12.8 versus CPU only and fifteen nvidia CUDA wheels missing from the venv; the findings fail GSI-TORCH-002 for the CPU-only build and warn GSI-DIFF-001 that the environments have different PyTorch builds.](https://raw.githubusercontent.com/BhuwanJoshi-01/gpu-stack-inspector/main/docs/images/compare.svg)
+
+> **Status:** 0.1.0 is the first release, validated on one laptop with five real environments. Reports from
+> other machines are very welcome.
+
+## Install
+
+The tool needs Python 3.11 or newer; the interpreters it inspects can be Python 3.8 or newer.
+
+```bash
+uv tool install git+https://github.com/BhuwanJoshi-01/gpu-stack-inspector   # until the PyPI release
+pipx install git+https://github.com/BhuwanJoshi-01/gpu-stack-inspector      # or with pipx
+```
+
+## Use
+
+```bash
+gpu-stack-inspector compare --python ~/envs/works/bin/python --python ~/envs/broken/bin/python
+gpu-stack-inspector inspect --python ~/envs/broken/bin/python      # one environment in detail
+gpu-stack-inspector probe --runtime --python ~/envs/broken/bin/python   # opt-in: really runs a tiny CUDA operation
+gpu-stack-inspector report --python ~/envs/broken/bin/python --output gpu-report.md   # redacted, for an issue
+gpu-stack-inspector rules list                                     # every check; `rules explain CODE` for one
+```
+
+Without `--python` it inspects the `python` your shell runs. See the [command reference](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/cli.md).
+
+## What it checks
+
+- **The machine**: driver tools, whether the driver answers and which CUDA versions it supports, the GPUs and their
+  compute capability, `CUDA_VISIBLE_DEVICES`.
+- **Each interpreter**: whether it starts, whether it is the one your shell runs, whether torch is installed where it
+  is needed, and which build it is (CUDA with its version, CPU-only, ROCm), decided from the version tag,
+  `torch/version.py`, the CUDA libraries in `torch/lib`, the `nvidia-*` requirements and conda's records, without
+  importing torch.
+- **Compatibility**: the driver against the CUDA version torch was built for and against nvcc, using dated,
+  source-tagged NVIDIA compatibility data.
+- **The comparison**: every field that differs, and whether the environments have different PyTorch builds.
+- **At runtime** (`probe --runtime` only): importing torch and running an operation on the GPU, step by step.
+
+Every finding has a stable code, the evidence it rests on, what to do next and the command to check it afterwards.
+[Troubleshooting](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/troubleshooting.md) explains the common ones.
+
+## What it promises
+
+- **Read-only.** It never installs, upgrades or changes anything, and never needs `sudo`. It writes nothing except a
+  report file you name.
+- **Your environments stay untouched.** A fixed probe program reads each interpreter's metadata. torch is only
+  imported with `probe --runtime`, because creating a CUDA context uses GPU memory and can hang on a broken system.
+- **Unknown is not a pass.** A check that could not run is unknown or not tested, never green.
+- **Shareable output.** Home paths, user and host names, secrets and tokens are redacted before anything is printed
+  or written, JSON included, and each report says what was redacted. No network access, no telemetry.
+
+Details in [privacy](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/privacy.md).
+
+## Tested on
+
+An Ubuntu 26.04 laptop with an RTX 3050 (driver 595.99.02) and five real environments: conda and uv, Python 3.8 to
+3.13, CUDA 11.3 to 13.0 builds and a CPU-only build. CI runs the tests on Linux and Windows and the probe in Python
+3.8 to 3.10 and PyPy. Windows and WSL with a GPU, containers and macOS are **not validated**; see the
+[support matrix](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/support-matrix.md).
+
+## Alternatives
+
+If you only need to check a single environment, these may already be enough:
+
+- [cuda-doctor](https://pypi.org/project/cuda-doctor/) checks the GPU, driver, toolkit, compiler and PyTorch of the
+  environment it is installed in.
+- [env-doctor](https://github.com/mitulgarg/env-doctor) checks the driver, CUDA, cuDNN and frameworks, and compares
+  machines in a fleet dashboard.
+- [cudadoc](https://www.cudadoc.com/docs/quickstart) includes a GPU validation suite.
+
+GPU Stack Inspector focuses on comparing **environments on the same machine**.
+
+## Documentation
+
+[Command reference](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/cli.md) · [Troubleshooting](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/troubleshooting.md) · [Privacy](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/privacy.md) ·
+[Support matrix](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/support-matrix.md) · [JSON output](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/json-output.md) · [Architecture](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/architecture.md) ·
+[Sample reports](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/tree/main/docs/sample-reports) · [Roadmap](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/docs/roadmap.md)
+
+## Contributing
+
+Test reports, fixtures from unusual systems, bug reports and pull requests are welcome; see
+[CONTRIBUTING.md](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/CONTRIBUTING.md). Security problems, including a report that leaks private data, go through
+[SECURITY.md](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/SECURITY.md).
+
+## License
+
+[MIT](https://github.com/BhuwanJoshi-01/gpu-stack-inspector/blob/main/LICENSE)

gpu_stack_inspector-0.1.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+gpu_stack_inspector/__init__.py,sha256=dJXcPa3gAk1Lr3JjLxEZHQ9pS80p6Y7ylewqH0okWMU,312
+gpu_stack_inspector/__main__.py,sha256=tmc5ufsSfSmgDN2QuJOsq8RlW70WjKaz1gFINtSd4Ug,128
+gpu_stack_inspector/cli.py,sha256=_D5XO1-7v8q7PnKVrSWgfeQ31dNeo8sCbpeXFF3ISug,11627
+gpu_stack_inspector/collectors/__init__.py,sha256=UvHX8m7P7cdXpAqQoW8ZoY5h3A2G3u3ilKxbFtOdHe8,82
+gpu_stack_inspector/collectors/environment.py,sha256=yKeNL2eGTA9W4qLPG6SU8lmBfUQM4wdO4yGxGdm9fSw,964
+gpu_stack_inspector/collectors/host.py,sha256=Duub9aC848bijkFUWgdjMkhVV_N9ofBot-dBtOwIO8c,1529
+gpu_stack_inspector/collectors/nvidia.py,sha256=dRwbY3-4oKxtsjc76W8HVkJFFMGw83OJjvy525YSXIo,6474
+gpu_stack_inspector/collectors/python_env.py,sha256=f2TI9feAhLv3qOMS1gkeasSHifxZ-uvUIyjg7mumLD8,2445
+gpu_stack_inspector/collectors/toolkit.py,sha256=UblkT0BMMbHQHzOcENeldrHHVBaBxBqSW5SqQEiSekM,6033
+gpu_stack_inspector/compatibility/__init__.py,sha256=TJYv_PUowuJROTrGnI06F40l0UGntQtDfxqf6D4uxXk,66
+gpu_stack_inspector/compatibility/data.json,sha256=zhPNBcwwBECbsYFO0P_JQLYAuJgeiDLwcG02AEodLpA,1061
+gpu_stack_inspector/compatibility/loader.py,sha256=w1rmv6P5o0DYhzPGPqpUWHyHtWEPMfzky6UzuSnal_Q,2490
+gpu_stack_inspector/compatibility/versions.py,sha256=X05dB9ktYeIAHCW7ocnb9R9OjTzolUFQYHpilxG9qzY,834
+gpu_stack_inspector/exit_codes.py,sha256=Ho_9iLzwyhdg2X2gysPa07QhlZaSYET7HBJJT43W_F0,624
+gpu_stack_inspector/models.py,sha256=AikJcsR9urr7pVkCcnTLUQlytyzeS2egUzghwMsHOcA,11139
+gpu_stack_inspector/orchestrator.py,sha256=BwA4GmyB8FPXBjD4GdnRuYl47CR9edSvOXc1pX9c0Bc,4906
+gpu_stack_inspector/privacy.py,sha256=HX-PxSRlCrpbOKQZhfriaI9ew8YLhUmsr_-SRAW0JGs,9617
+gpu_stack_inspector/probes/__init__.py,sha256=frWsRtpoGKb9mbZ2PaMHWWQd705IsB_55isbjJPrI6E,82
+gpu_stack_inspector/probes/metadata_probe.py,sha256=zAyonIfxsMLuGL2yjR-HBu2RXAhTNwHX5iyRIMIfIAw,9034
+gpu_stack_inspector/probes/metadata_program.py,sha256=XWlbw5Rf2aZig3OuBYMcCrlM5T-LhBGt1f2qbFlo3cs,8626
+gpu_stack_inspector/probes/runtime_probe.py,sha256=0cWM1tTMdEqWPyRNPdr8At-Byl1COFCZTE4kU08OPVc,5793
+gpu_stack_inspector/probes/runtime_program.py,sha256=xofX8l4rrcJeB5Vsv6H97lUch9Jh5izo-KkZn3ke8Oo,3642
+gpu_stack_inspector/reports/__init__.py,sha256=6iGY7rFTa5ktGL0b0TGufqpyHRiWWr3BpfEg1SKJ1bY,89
+gpu_stack_inspector/reports/json_report.py,sha256=duYjE2qViu7xNX1HNjnkMjkv-DED_mAHbvl-Br4-MTw,1730
+gpu_stack_inspector/reports/markdown.py,sha256=74rcrvfLPTpJtoK-romtoYehlJy-ev9S2MmejUXCbWQ,7472
+gpu_stack_inspector/reports/terminal.py,sha256=XClXXDOfYTZ8fPS5FLUqUVbGa4AZHCI91DQSjuL6sb4,11330
+gpu_stack_inspector/rules/__init__.py,sha256=fD9lbPmNoP91YhOhDY9xYicy1lmaX-nPtT05J-fpSSc,95
+gpu_stack_inspector/rules/catalog.py,sha256=5c1co1lmEKrZC_uycEtVuzBYTMNgnMapg0RxPr_HIBY,705
+gpu_stack_inspector/rules/comparison.py,sha256=5nsECvfWBElFpjmblobvByzQUmyjPtwZtqKzM-pXbr0,2892
+gpu_stack_inspector/rules/compatibility.py,sha256=jgApZOh4rRtvq28bJ5Jveex1YGLldGM0OIrv3F-Cjug,10268
+gpu_stack_inspector/rules/differences.py,sha256=z8qiHPXZICizaiRU39SGOafuReM60mQKifGQEWwq4Do,2594
+gpu_stack_inspector/rules/engine.py,sha256=DOH8UVkatvW-YRwmdnQLuS07DBi5U8KH0HwzMYG_2q4,3582
+gpu_stack_inspector/rules/host.py,sha256=tO8kccA7ufnKayACP2zDDLgrYZu-_Aw9b-0G6kbLZx0,10695
+gpu_stack_inspector/rules/interpreters.py,sha256=kL1TloMD9AhdVkJK_1ShY-bPtj27mq95Zpsd6oh2Nkk,19567
+gpu_stack_inspector/rules/torch_build.py,sha256=hjmZMc2D4LODDM63CxGuJNfPhY2z0wzI8aQiqTjxyIg,9348
+gpu_stack_inspector/runner.py,sha256=ZT95pEgGacd3kWyjVXEvXU0WDP_eQl41XID7HrhyjK8,9204
+gpu_stack_inspector-0.1.0.dist-info/licenses/LICENSE,sha256=qpnoghKC1sfa6tVZTac6xDaNwFgOvSqQIYH0s3szqFc,1071
+gpu_stack_inspector-0.1.0.dist-info/WHEEL,sha256=MWx7psoF7KNST9G72pGtiBYuaXRXQXBk9pw5R6FzYko,80
+gpu_stack_inspector-0.1.0.dist-info/entry_points.txt,sha256=G__M6nBl-XGQjLr_CkHrjTyOTbrTibNu4cpf122PjJQ,70
+gpu_stack_inspector-0.1.0.dist-info/METADATA,sha256=bXLePLnBTa5nIt1Z7suHPNBMqUM76OxqN9gFJCPTtAI,8389
+gpu_stack_inspector-0.1.0.dist-info/RECORD,,

gpu_stack_inspector-0.1.0.dist-info/WHEEL

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

gpu_stack_inspector-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+gpu-stack-inspector = gpu_stack_inspector.cli:main
+

gpu_stack_inspector-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BhuwanJoshi-01
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.