deepbom 0.1.0__tar.gz

deepbom-0.1.0/LICENSE

@@ -0,0 +1,15 @@
+Copyright (C) 2026 Jun-Hwan Kwon. All rights reserved.
+
+This repository and its generated software artifacts are currently provided as
+private research software. No license is granted to copy, modify, distribute,
+sublicense, reverse engineer, or create derivative works from the source code,
+WebAssembly modules, generated JavaScript bindings, or packaged executables,
+except where a separate file or component carries an explicit license.
+
+Access to the hosted service does not grant a software or implementation
+license.
+
+Future public releases may license selected contracts, conformance fixtures,
+validation data, or automation clients separately. A license applies only to
+the files and versions that explicitly carry it. Third-party dependencies and
+model artifacts remain subject to their respective licenses.

deepbom-0.1.0/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: deepbom
+Version: 0.1.0
+Summary: Deployment-artifact inspection for on-device neural network models
+Author: Jun-Hwan Kwon
+License: Copyright (C) 2026 Jun-Hwan Kwon. All rights reserved.
+        
+        This repository and its generated software artifacts are currently provided as
+        private research software. No license is granted to copy, modify, distribute,
+        sublicense, reverse engineer, or create derivative works from the source code,
+        WebAssembly modules, generated JavaScript bindings, or packaged executables,
+        except where a separate file or component carries an explicit license.
+        
+        Access to the hosted service does not grant a software or implementation
+        license.
+        
+        Future public releases may license selected contracts, conformance fixtures,
+        validation data, or automation clients separately. A license applies only to
+        the files and versions that explicitly carry it. Third-party dependencies and
+        model artifacts remain subject to their respective licenses.
+        
+Project-URL: Homepage, https://deepbom.org
+Keywords: gguf,safetensors,tflite,onnx,coreml,on-device,edge-ai,quantization,ml-bom,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: ISC License (ISCL)
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# deepbom
+
+Deployment-artifact inspection for on-device neural network models.
+
+Identifies model artifact formats from their container signature and reads the
+contracts that can be decoded without loading tensor payload values.
+
+```console
+$ pip install deepbom
+$ deepbom inspect model.safetensors
+
+model.safetensors
+  sha256   a35fd03f52c12f4e78a246bec1927e9a169377fbb8905dc13165d285010e7a44
+  format   safetensors   size 2.6 MB
+  evidence u64 header length followed by a JSON header
+
+tensors
+  count              38
+  parameters         1,377,408
+  stored payload     2.6 MB
+  dtypes             F16 x38
+
+Container-level facts only. No tensor payload values were read.
+```
+
+```console
+$ deepbom inspect model.gguf
+
+model.gguf
+  sha256   cb95a6e10f28b76a1dd71c15560dec5a5eee8943f591ef45d11c129786b22cff
+  format   gguf   size 509.0 KB
+  evidence magic "GGUF" at offset 0
+
+container
+  gguf version       3
+  tensors            39
+  metadata           26 / 26 (complete)
+  architecture       llama
+  file type          2
+  quant version      2
+```
+
+## What it reads
+
+| Format | Reported |
+| --- | --- |
+| **SafeTensors** | tensor inventory, dtypes, shapes, parameter count, stored payload bytes, metadata, header/file size agreement |
+| **GGUF** | version, tensor count, full metadata key/value inventory, architecture, file type, quantization version |
+| TFLite, ONNX, Core ML | format identification and SHA-256 only |
+
+Format is decided from container evidence — FlatBuffer identifier, magic
+bytes, header structure — never from the filename extension. ONNX and Core ML
+are separated by their protobuf field layout rather than guessed.
+
+## Usage
+
+```console
+deepbom inspect <file>
+deepbom inspect <file> --json
+deepbom --version
+```
+
+As a library:
+
+```python
+from deepbom import inspect
+
+artifact = inspect("model.gguf")
+print(artifact.format, artifact.sha256)
+print(artifact.detail["architecture"])
+print(artifact.to_dict())
+```
+
+## Scope
+
+This package is pure Python with no dependencies. It reports **container-level
+facts only**: what the header and directory structures determine. Tensor
+payload values are never read, and nothing is inferred that the container does
+not state.
+
+Graph structure, quantization contracts, predicted delegate placement,
+target-profile cost projections and CycloneDX ML-BOM export are **not** part of
+this package. For TFLite graph analysis:
+
+```console
+npx deepbom audit model.tflite
+```
+
+ONNX, Core ML and runtime evidence are available in the browser version at
+<https://deepbom.org>.
+
+## Privacy
+
+No network access. Model bytes, filenames and results are never uploaded.
+
+## License
+
+ISC — see [LICENSE](./LICENSE).

deepbom-0.1.0/README.md

@@ -0,0 +1,98 @@
+# deepbom
+
+Deployment-artifact inspection for on-device neural network models.
+
+Identifies model artifact formats from their container signature and reads the
+contracts that can be decoded without loading tensor payload values.
+
+```console
+$ pip install deepbom
+$ deepbom inspect model.safetensors
+
+model.safetensors
+  sha256   a35fd03f52c12f4e78a246bec1927e9a169377fbb8905dc13165d285010e7a44
+  format   safetensors   size 2.6 MB
+  evidence u64 header length followed by a JSON header
+
+tensors
+  count              38
+  parameters         1,377,408
+  stored payload     2.6 MB
+  dtypes             F16 x38
+
+Container-level facts only. No tensor payload values were read.
+```
+
+```console
+$ deepbom inspect model.gguf
+
+model.gguf
+  sha256   cb95a6e10f28b76a1dd71c15560dec5a5eee8943f591ef45d11c129786b22cff
+  format   gguf   size 509.0 KB
+  evidence magic "GGUF" at offset 0
+
+container
+  gguf version       3
+  tensors            39
+  metadata           26 / 26 (complete)
+  architecture       llama
+  file type          2
+  quant version      2
+```
+
+## What it reads
+
+| Format | Reported |
+| --- | --- |
+| **SafeTensors** | tensor inventory, dtypes, shapes, parameter count, stored payload bytes, metadata, header/file size agreement |
+| **GGUF** | version, tensor count, full metadata key/value inventory, architecture, file type, quantization version |
+| TFLite, ONNX, Core ML | format identification and SHA-256 only |
+
+Format is decided from container evidence — FlatBuffer identifier, magic
+bytes, header structure — never from the filename extension. ONNX and Core ML
+are separated by their protobuf field layout rather than guessed.
+
+## Usage
+
+```console
+deepbom inspect <file>
+deepbom inspect <file> --json
+deepbom --version
+```
+
+As a library:
+
+```python
+from deepbom import inspect
+
+artifact = inspect("model.gguf")
+print(artifact.format, artifact.sha256)
+print(artifact.detail["architecture"])
+print(artifact.to_dict())
+```
+
+## Scope
+
+This package is pure Python with no dependencies. It reports **container-level
+facts only**: what the header and directory structures determine. Tensor
+payload values are never read, and nothing is inferred that the container does
+not state.
+
+Graph structure, quantization contracts, predicted delegate placement,
+target-profile cost projections and CycloneDX ML-BOM export are **not** part of
+this package. For TFLite graph analysis:
+
+```console
+npx deepbom audit model.tflite
+```
+
+ONNX, Core ML and runtime evidence are available in the browser version at
+<https://deepbom.org>.
+
+## Privacy
+
+No network access. Model bytes, filenames and results are never uploaded.
+
+## License
+
+ISC — see [LICENSE](./LICENSE).

deepbom-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "deepbom"
+version = "0.1.0"
+description = "Deployment-artifact inspection for on-device neural network models"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { file = "LICENSE" }
+authors = [{ name = "Jun-Hwan Kwon" }]
+keywords = [
+    "gguf", "safetensors", "tflite", "onnx", "coreml",
+    "on-device", "edge-ai", "quantization", "ml-bom", "static-analysis",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: ISC License (ISCL)",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Quality Assurance",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://deepbom.org"
+
+[project.scripts]
+deepbom = "deepbom.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

deepbom-0.1.0/setup.cfg

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

deepbom-0.1.0/src/deepbom/__init__.py

@@ -0,0 +1,12 @@
+"""Deployment-artifact inspection for on-device neural network models.
+
+Identifies model artifact formats and reads the container-level contracts that
+can be decoded without loading tensor payload values.
+
+This package performs no network access. Model bytes stay on the machine.
+"""
+
+from .inspect import Artifact, InspectionError, identify, inspect
+
+__version__ = "0.1.0"
+__all__ = ["Artifact", "InspectionError", "identify", "inspect", "__version__"]

deepbom-0.1.0/src/deepbom/__main__.py

@@ -0,0 +1,98 @@
+"""Command line entry point: ``deepbom`` / ``python -m deepbom``."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from . import __version__
+from .inspect import Artifact, InspectionError, inspect
+
+
+def _fmt_bytes(value: int) -> str:
+    size = float(value)
+    for unit in ("B", "KB", "MB", "GB"):
+        if size < 1024 or unit == "GB":
+            return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} GB"
+
+
+def _render(artifact: Artifact) -> str:
+    out: list[str] = []
+    detail = artifact.detail
+    out.append(artifact.path)
+    out.append(f"  sha256   {artifact.sha256}")
+    out.append(f"  format   {artifact.format}   size {_fmt_bytes(artifact.size_bytes)}")
+    out.append(f"  evidence {artifact.format_evidence}")
+    out.append("")
+
+    if artifact.format == "safetensors":
+        out.append("tensors")
+        out.append(f"  count              {detail['tensor_count']:,}")
+        out.append(f"  parameters         {detail['parameter_count']:,}")
+        out.append(f"  stored payload     {_fmt_bytes(detail['stored_payload_bytes'])}")
+        dtypes = ", ".join(f"{k} x{v}" for k, v in detail["dtype_counts"].items())
+        out.append(f"  dtypes             {dtypes}")
+        if detail.get("metadata"):
+            out.append(f"  metadata keys      {', '.join(sorted(detail['metadata'])[:6])}")
+        out.append("")
+    elif artifact.format == "gguf":
+        out.append("container")
+        out.append(f"  gguf version       {detail['gguf_version']}")
+        out.append(f"  tensors            {detail['tensor_count']:,}")
+        complete = "complete" if detail.get("metadata_complete") else "partial"
+        out.append(
+            f"  metadata           {detail['metadata_decoded_count']:,} / "
+            f"{detail['metadata_kv_count']:,} ({complete})"
+        )
+        for label, key in (("architecture", "architecture"), ("name", "name"),
+                           ("file type", "file_type"), ("quant version", "quantization_version")):
+            if detail.get(key) is not None:
+                out.append(f"  {label:<18} {detail[key]}")
+        out.append("")
+
+    if artifact.notes:
+        out.append("notes")
+        for note in artifact.notes:
+            out.append(f"  - {note}")
+        out.append("")
+
+    out.append("Container-level facts only. No tensor payload values were read.")
+    return "\n".join(out)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="deepbom",
+        description="Deployment-artifact inspection for on-device neural network models.",
+        epilog="Graph, quantization and delegate analysis: `npx deepbom audit` or https://deepbom.org",
+    )
+    parser.add_argument("--version", action="version", version=__version__)
+    sub = parser.add_subparsers(dest="command")
+
+    inspect_cmd = sub.add_parser("inspect", help="Inspect an artifact container")
+    inspect_cmd.add_argument("path", help="Path to a model artifact")
+    inspect_cmd.add_argument("--json", action="store_true", help="Emit JSON")
+
+    args = parser.parse_args(argv)
+    if args.command != "inspect":
+        parser.print_help()
+        return 1
+
+    try:
+        artifact = inspect(args.path)
+    except InspectionError as error:
+        print(f"deepbom: {error}", file=sys.stderr)
+        return 2
+
+    if args.json:
+        print(json.dumps(artifact.to_dict(), indent=2, ensure_ascii=False))
+    else:
+        print(_render(artifact))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

deepbom-0.1.0/src/deepbom/inspect.py

@@ -0,0 +1,310 @@
+"""Format identification and container-level inspection.
+
+Only facts the serialized container determines are reported. Nothing is
+inferred from a filename extension, and tensor payload values are never read.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import struct
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+# GGUF value type ids, ggml/gguf.md
+_GGUF_TYPES = {
+    0: ("uint8", "<B", 1), 1: ("int8", "<b", 1),
+    2: ("uint16", "<H", 2), 3: ("int16", "<h", 2),
+    4: ("uint32", "<I", 4), 5: ("int32", "<i", 4),
+    6: ("float32", "<f", 4), 7: ("bool", "<?", 1),
+    8: ("string", None, None), 9: ("array", None, None),
+    10: ("uint64", "<Q", 8), 11: ("int64", "<q", 8),
+    12: ("float64", "<d", 8),
+}
+
+_SAFETENSORS_DTYPE_BITS = {
+    "BOOL": 1, "U8": 8, "I8": 8, "F8_E4M3": 8, "F8_E5M2": 8,
+    "U16": 16, "I16": 16, "F16": 16, "BF16": 16,
+    "U32": 32, "I32": 32, "F32": 32,
+    "U64": 64, "I64": 64, "F64": 64,
+}
+
+_READ_LIMIT = 64 * 1024 * 1024  # header scan ceiling
+
+
+class InspectionError(Exception):
+    """Raised when a file cannot be inspected as a supported artifact."""
+
+
+@dataclass
+class Artifact:
+    """Container-level facts about one artifact."""
+
+    path: str
+    size_bytes: int
+    sha256: str
+    format: str
+    format_evidence: str
+    detail: dict[str, Any] = field(default_factory=dict)
+    notes: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schema": "deepbom.artifact_inspection.v1",
+            "path": self.path,
+            "size_bytes": self.size_bytes,
+            "sha256": self.sha256,
+            "format": self.format,
+            "format_evidence": self.format_evidence,
+            "detail": self.detail,
+            "notes": self.notes,
+        }
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1 << 20), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def identify(head: bytes) -> tuple[str, str]:
+    """Return (format, evidence) from leading bytes alone."""
+    if len(head) >= 8 and head[4:8] == b"TFL3":
+        return "tflite", 'FlatBuffer file identifier "TFL3" at offset 4'
+    if head[:4] == b"GGUF":
+        return "gguf", 'magic "GGUF" at offset 0'
+    if head[:4] == b"PK\x03\x04":
+        return "zip-container", "ZIP local file header — Core ML .mlpackage or archived artifact"
+    if len(head) >= 8:
+        # SafeTensors: u64 little-endian header length, then a JSON object
+        (header_len,) = struct.unpack("<Q", head[:8])
+        if 2 <= header_len <= _READ_LIMIT and head[8:9] == b"{":
+            return "safetensors", "u64 header length followed by a JSON header"
+    protobuf = _classify_protobuf(head)
+    if protobuf is not None:
+        return protobuf
+    return "unknown", "no recognised container signature"
+
+
+def _read_varint(buf: bytes, index: int) -> tuple[int, int]:
+    """Return (value, next_index) for a protobuf varint."""
+    value = 0
+    shift = 0
+    while index < len(buf):
+        byte = buf[index]
+        value |= (byte & 0x7F) << shift
+        index += 1
+        if not byte & 0x80:
+            return value, index
+        shift += 7
+        if shift > 63:
+            break
+    raise InspectionError("truncated varint")
+
+
+def _classify_protobuf(head: bytes) -> tuple[str, str] | None:
+    """Separate ONNX ModelProto from Core ML Model by their second field.
+
+    Both start with field 1 as a varint. ONNX field 2 is `producer_name`, a
+    short printable string; Core ML field 2 is the `description` message.
+    """
+    if not head[:1] == b"\x08":
+        return None
+    try:
+        _, index = _read_varint(head, 1)
+        if index >= len(head) or head[index] != 0x12:
+            return None
+        length, after = _read_varint(head, index + 1)
+        length_bytes = after - (index + 1)
+        payload = head[after:after + min(length, 48)]
+    except InspectionError:
+        return None
+
+    printable = bool(payload) and all(32 <= byte < 127 for byte in payload)
+    if length_bytes == 1 and length <= 64 and printable:
+        return "onnx", "protobuf ir_version followed by a printable producer_name string"
+    return "coreml", "protobuf specificationVersion followed by a description message"
+
+
+def _inspect_safetensors(path: Path, size: int) -> tuple[dict[str, Any], list[str]]:
+    with path.open("rb") as handle:
+        (header_len,) = struct.unpack("<Q", handle.read(8))
+        if header_len > _READ_LIMIT or 8 + header_len > size:
+            raise InspectionError("SafeTensors header length exceeds the file")
+        header = json.loads(handle.read(header_len).decode("utf-8"))
+
+    tensors: list[dict[str, Any]] = []
+    dtypes: dict[str, int] = {}
+    total_elements = 0
+    stored_bytes = 0
+    for name, entry in header.items():
+        if name == "__metadata__":
+            continue
+        shape = entry.get("shape", [])
+        dtype = entry.get("dtype", "UNKNOWN")
+        offsets = entry.get("data_offsets", [0, 0])
+        elements = 1
+        for dim in shape:
+            elements *= int(dim)
+        if not shape:
+            elements = 1
+        total_elements += elements
+        stored_bytes += int(offsets[1]) - int(offsets[0])
+        dtypes[dtype] = dtypes.get(dtype, 0) + 1
+        tensors.append({"name": name, "dtype": dtype, "shape": shape, "elements": elements})
+
+    detail: dict[str, Any] = {
+        "tensor_count": len(tensors),
+        "parameter_count": total_elements,
+        "stored_payload_bytes": stored_bytes,
+        "dtype_counts": dict(sorted(dtypes.items())),
+        "metadata": header.get("__metadata__", {}),
+        "tensors": tensors,
+    }
+
+    notes: list[str] = []
+    declared_end = 8 + header_len + stored_bytes
+    if declared_end != size:
+        notes.append(
+            f"declared payload ends at {declared_end} but the file is {size} bytes "
+            f"({size - declared_end:+d})"
+        )
+    for dtype, count in dtypes.items():
+        if dtype not in _SAFETENSORS_DTYPE_BITS:
+            notes.append(f"unrecognised dtype {dtype!r} on {count} tensor(s)")
+    return detail, notes
+
+
+def _read_gguf_string(handle) -> str:
+    (length,) = struct.unpack("<Q", handle.read(8))
+    if length > 1 << 20:
+        raise InspectionError("GGUF string length is implausible")
+    return handle.read(length).decode("utf-8", errors="replace")
+
+
+def _read_gguf_value(handle, type_id: int, depth: int = 0) -> Any:
+    if type_id not in _GGUF_TYPES:
+        raise InspectionError(f"unknown GGUF value type {type_id}")
+    name, fmt, width = _GGUF_TYPES[type_id]
+    if name == "string":
+        return _read_gguf_string(handle)
+    if name == "array":
+        if depth > 1:
+            raise InspectionError("nested GGUF arrays are not decoded")
+        (elem_type,) = struct.unpack("<I", handle.read(4))
+        (count,) = struct.unpack("<Q", handle.read(8))
+        if count > 1 << 26:
+            raise InspectionError("GGUF array length is implausible")
+        if elem_type not in _GGUF_TYPES:
+            raise InspectionError(f"unknown GGUF array element type {elem_type}")
+        elem_name, _, elem_width = _GGUF_TYPES[elem_type]
+        if count <= 64:
+            return [_read_gguf_value(handle, elem_type, depth + 1) for _ in range(count)]
+        # Large arrays (tokenizer vocabularies) are summarised, but their bytes
+        # must still be consumed or every following key/value misaligns.
+        if elem_width is not None:
+            handle.seek(count * elem_width, 1)
+        elif elem_name == "string":
+            for _ in range(count):
+                (length,) = struct.unpack("<Q", handle.read(8))
+                if length > 1 << 20:
+                    raise InspectionError("GGUF string length is implausible")
+                handle.seek(length, 1)
+        else:
+            raise InspectionError(f"cannot skip a large array of {elem_name}")
+        return {"array_type": elem_name, "length": count, "elided": True}
+    return struct.unpack(fmt, handle.read(width))[0]
+
+
+def _inspect_gguf(path: Path, size: int) -> tuple[dict[str, Any], list[str]]:
+    notes: list[str] = []
+    with path.open("rb") as handle:
+        handle.read(4)  # magic
+        version, tensor_count, kv_count = struct.unpack("<IQQ", handle.read(20))
+        if version not in (2, 3):
+            notes.append(f"GGUF version {version} is outside the versions this reader decodes (2, 3)")
+        metadata: dict[str, Any] = {}
+        truncated = False
+        if version in (2, 3):
+            try:
+                for _ in range(kv_count):
+                    key = _read_gguf_string(handle)
+                    (type_id,) = struct.unpack("<I", handle.read(4))
+                    metadata[key] = _read_gguf_value(handle, type_id)
+            except (InspectionError, struct.error, UnicodeDecodeError) as error:
+                truncated = True
+                notes.append(f"metadata decoding stopped early: {error}")
+
+    detail: dict[str, Any] = {
+        "gguf_version": version,
+        "tensor_count": tensor_count,
+        "metadata_kv_count": kv_count,
+        "metadata_decoded_count": len(metadata),
+        "architecture": metadata.get("general.architecture"),
+        "name": metadata.get("general.name"),
+        "file_type": metadata.get("general.file_type"),
+        "quantization_version": metadata.get("general.quantization_version"),
+        "metadata": metadata,
+    }
+    if truncated:
+        detail["metadata_complete"] = False
+    else:
+        detail["metadata_complete"] = len(metadata) == kv_count
+    return detail, notes
+
+
+def _inspect_tflite(path: Path, size: int) -> tuple[dict[str, Any], list[str]]:
+    return (
+        {"file_identifier": "TFL3"},
+        [
+            "Graph, quantization and delegate analysis for TFLite is not implemented in this "
+            "pure-Python package. Use `npx deepbom audit` or https://deepbom.org",
+        ],
+    )
+
+
+def inspect(path: str | Path) -> Artifact:
+    """Inspect one artifact and return container-level facts."""
+    target = Path(path)
+    if not target.is_file():
+        raise InspectionError(f"not a file: {target}")
+    size = target.stat().st_size
+    if size == 0:
+        raise InspectionError(f"empty file: {target}")
+
+    with target.open("rb") as handle:
+        head = handle.read(1024)
+    fmt, evidence = identify(head)
+
+    detail: dict[str, Any] = {}
+    notes: list[str] = []
+    try:
+        if fmt == "safetensors":
+            detail, notes = _inspect_safetensors(target, size)
+        elif fmt == "gguf":
+            detail, notes = _inspect_gguf(target, size)
+        elif fmt == "tflite":
+            detail, notes = _inspect_tflite(target, size)
+        elif fmt in ("onnx", "coreml", "zip-container"):
+            notes = [
+                f"{fmt} container inspection is not implemented in this pure-Python package. "
+                "Use https://deepbom.org",
+            ]
+        else:
+            notes = ["Unrecognised container. No format-specific facts are reported."]
+    except (struct.error, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise InspectionError(f"{fmt} header could not be decoded: {error}") from error
+
+    return Artifact(
+        path=str(target),
+        size_bytes=size,
+        sha256=_sha256(target),
+        format=fmt,
+        format_evidence=evidence,
+        detail=detail,
+        notes=notes,
+    )

deepbom-0.1.0/src/deepbom.egg-info/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: deepbom
+Version: 0.1.0
+Summary: Deployment-artifact inspection for on-device neural network models
+Author: Jun-Hwan Kwon
+License: Copyright (C) 2026 Jun-Hwan Kwon. All rights reserved.
+        
+        This repository and its generated software artifacts are currently provided as
+        private research software. No license is granted to copy, modify, distribute,
+        sublicense, reverse engineer, or create derivative works from the source code,
+        WebAssembly modules, generated JavaScript bindings, or packaged executables,
+        except where a separate file or component carries an explicit license.
+        
+        Access to the hosted service does not grant a software or implementation
+        license.
+        
+        Future public releases may license selected contracts, conformance fixtures,
+        validation data, or automation clients separately. A license applies only to
+        the files and versions that explicitly carry it. Third-party dependencies and
+        model artifacts remain subject to their respective licenses.
+        
+Project-URL: Homepage, https://deepbom.org
+Keywords: gguf,safetensors,tflite,onnx,coreml,on-device,edge-ai,quantization,ml-bom,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: ISC License (ISCL)
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# deepbom
+
+Deployment-artifact inspection for on-device neural network models.
+
+Identifies model artifact formats from their container signature and reads the
+contracts that can be decoded without loading tensor payload values.
+
+```console
+$ pip install deepbom
+$ deepbom inspect model.safetensors
+
+model.safetensors
+  sha256   a35fd03f52c12f4e78a246bec1927e9a169377fbb8905dc13165d285010e7a44
+  format   safetensors   size 2.6 MB
+  evidence u64 header length followed by a JSON header
+
+tensors
+  count              38
+  parameters         1,377,408
+  stored payload     2.6 MB
+  dtypes             F16 x38
+
+Container-level facts only. No tensor payload values were read.
+```
+
+```console
+$ deepbom inspect model.gguf
+
+model.gguf
+  sha256   cb95a6e10f28b76a1dd71c15560dec5a5eee8943f591ef45d11c129786b22cff
+  format   gguf   size 509.0 KB
+  evidence magic "GGUF" at offset 0
+
+container
+  gguf version       3
+  tensors            39
+  metadata           26 / 26 (complete)
+  architecture       llama
+  file type          2
+  quant version      2
+```
+
+## What it reads
+
+| Format | Reported |
+| --- | --- |
+| **SafeTensors** | tensor inventory, dtypes, shapes, parameter count, stored payload bytes, metadata, header/file size agreement |
+| **GGUF** | version, tensor count, full metadata key/value inventory, architecture, file type, quantization version |
+| TFLite, ONNX, Core ML | format identification and SHA-256 only |
+
+Format is decided from container evidence — FlatBuffer identifier, magic
+bytes, header structure — never from the filename extension. ONNX and Core ML
+are separated by their protobuf field layout rather than guessed.
+
+## Usage
+
+```console
+deepbom inspect <file>
+deepbom inspect <file> --json
+deepbom --version
+```
+
+As a library:
+
+```python
+from deepbom import inspect
+
+artifact = inspect("model.gguf")
+print(artifact.format, artifact.sha256)
+print(artifact.detail["architecture"])
+print(artifact.to_dict())
+```
+
+## Scope
+
+This package is pure Python with no dependencies. It reports **container-level
+facts only**: what the header and directory structures determine. Tensor
+payload values are never read, and nothing is inferred that the container does
+not state.
+
+Graph structure, quantization contracts, predicted delegate placement,
+target-profile cost projections and CycloneDX ML-BOM export are **not** part of
+this package. For TFLite graph analysis:
+
+```console
+npx deepbom audit model.tflite
+```
+
+ONNX, Core ML and runtime evidence are available in the browser version at
+<https://deepbom.org>.
+
+## Privacy
+
+No network access. Model bytes, filenames and results are never uploaded.
+
+## License
+
+ISC — see [LICENSE](./LICENSE).

deepbom-0.1.0/src/deepbom.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/deepbom/__init__.py
+src/deepbom/__main__.py
+src/deepbom/inspect.py
+src/deepbom.egg-info/PKG-INFO
+src/deepbom.egg-info/SOURCES.txt
+src/deepbom.egg-info/dependency_links.txt
+src/deepbom.egg-info/entry_points.txt
+src/deepbom.egg-info/top_level.txt

deepbom-0.1.0/src/deepbom.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

deepbom-0.1.0/src/deepbom.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+deepbom = deepbom.__main__:main

deepbom-0.1.0/src/deepbom.egg-info/top_level.txt

@@ -0,0 +1 @@
+deepbom