trnblas 0.2.0__py3-none-any.whl

trnblas/__init__.py

@@ -0,0 +1,35 @@
+"""
+trnblas — BLAS operations for AWS Trainium via NKI.
+
+Provides Level 1 (vector), Level 2 (matrix-vector), and Level 3 (matrix-matrix)
+BLAS operations with NKI kernel acceleration on Trainium hardware.
+Part of the trn-* scientific computing suite by Playground Logic.
+
+Target workloads: DF-MP2 tensor contractions, Fock matrix builds,
+Cholesky-based density fitting, and general scientific linear algebra.
+"""
+
+__version__ = "0.2.0"
+
+# Level 1 — Vector operations
+from .level1 import axpy, dot, nrm2, scal, asum, iamax
+
+# Level 2 — Matrix-vector operations
+from .level2 import gemv, symv, trmv, ger
+
+# Level 3 — Matrix-matrix operations
+from .level3 import gemm, batched_gemm, symm, syrk, trsm, trmm
+
+# Backend control
+from .nki import HAS_NKI, set_backend, get_backend
+
+__all__ = [
+    # Level 1
+    "axpy", "dot", "nrm2", "scal", "asum", "iamax",
+    # Level 2
+    "gemv", "symv", "trmv", "ger",
+    # Level 3
+    "gemm", "batched_gemm", "symm", "syrk", "trsm", "trmm",
+    # Backend
+    "HAS_NKI", "set_backend", "get_backend",
+]

trnblas/level1.py

@@ -0,0 +1,45 @@
+"""
+BLAS Level 1 — Vector operations.
+
+axpy, dot, nrm2, scal, asum, iamax
+All operate on torch tensors with NKI dispatch for Trainium acceleration.
+"""
+
+from __future__ import annotations
+
+import math
+import torch
+from typing import Optional
+
+
+def axpy(alpha: float, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+    """y = alpha * x + y"""
+    return alpha * x + y
+
+
+def dot(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+    """Dot product: x^T y
+
+    Returns scalar tensor.
+    """
+    return torch.dot(x.reshape(-1), y.reshape(-1))
+
+
+def nrm2(x: torch.Tensor) -> torch.Tensor:
+    """Euclidean norm: ||x||_2"""
+    return torch.linalg.norm(x.reshape(-1))
+
+
+def scal(alpha: float, x: torch.Tensor) -> torch.Tensor:
+    """x = alpha * x"""
+    return alpha * x
+
+
+def asum(x: torch.Tensor) -> torch.Tensor:
+    """Sum of absolute values: sum(|x_i|)"""
+    return torch.abs(x).sum()
+
+
+def iamax(x: torch.Tensor) -> int:
+    """Index of element with maximum absolute value."""
+    return torch.argmax(torch.abs(x.reshape(-1))).item()

trnblas/level2.py

@@ -0,0 +1,86 @@
+"""
+BLAS Level 2 — Matrix-vector operations.
+
+gemv, symv, trmv, ger
+"""
+
+from __future__ import annotations
+
+import torch
+from typing import Optional
+
+
+def gemv(
+    alpha: float,
+    A: torch.Tensor,
+    x: torch.Tensor,
+    beta: float = 0.0,
+    y: Optional[torch.Tensor] = None,
+    trans: bool = False,
+) -> torch.Tensor:
+    """General matrix-vector multiply: y = alpha * op(A) * x + beta * y
+
+    op(A) = A if trans=False, A^T if trans=True.
+    """
+    mat = A.T if trans else A
+    result = alpha * torch.mv(mat, x)
+    if y is not None and beta != 0.0:
+        result = result + beta * y
+    return result
+
+
+def symv(
+    alpha: float,
+    A: torch.Tensor,
+    x: torch.Tensor,
+    beta: float = 0.0,
+    y: Optional[torch.Tensor] = None,
+    uplo: str = "upper",
+) -> torch.Tensor:
+    """Symmetric matrix-vector multiply: y = alpha * A * x + beta * y
+
+    A is symmetric; only the upper or lower triangle is referenced.
+    """
+    if uplo == "upper":
+        sym = torch.triu(A) + torch.triu(A, diagonal=1).T
+    else:
+        sym = torch.tril(A) + torch.tril(A, diagonal=-1).T
+    result = alpha * torch.mv(sym, x)
+    if y is not None and beta != 0.0:
+        result = result + beta * y
+    return result
+
+
+def trmv(
+    A: torch.Tensor,
+    x: torch.Tensor,
+    uplo: str = "upper",
+    trans: bool = False,
+    diag: str = "nonunit",
+) -> torch.Tensor:
+    """Triangular matrix-vector multiply: x = op(A) * x
+
+    uplo: 'upper' or 'lower'
+    diag: 'unit' or 'nonunit'
+    """
+    if uplo == "upper":
+        tri = torch.triu(A)
+    else:
+        tri = torch.tril(A)
+    if diag == "unit":
+        tri = tri - torch.diag(torch.diag(tri)) + torch.eye(A.shape[0], dtype=A.dtype, device=A.device)
+    mat = tri.T if trans else tri
+    return torch.mv(mat, x)
+
+
+def ger(
+    alpha: float,
+    x: torch.Tensor,
+    y: torch.Tensor,
+    A: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+    """Rank-1 update: A = alpha * x * y^T + A"""
+    result = alpha * torch.outer(x, y)
+    if A is not None:
+        result = result + A
+    return result

trnblas/level3.py

@@ -0,0 +1,203 @@
+"""
+BLAS Level 3 — Matrix-matrix operations.
+
+gemm, symm, syrk, trsm, trmm
+
+These are the critical path for scientific computing on Trainium:
+- DF-MP2 tensor contractions → batched GEMM
+- Fock matrix build → SYMM
+- Cholesky-based density fitting → TRSM
+- Metric contraction J^{-1/2} → SYRK
+
+NKI dispatch for GEMM provides stationary tile reuse on the Tensor Engine.
+"""
+
+from __future__ import annotations
+
+import torch
+from typing import Optional
+
+from .nki import get_backend, HAS_NKI
+
+
+def gemm(
+    alpha: float,
+    A: torch.Tensor,
+    B: torch.Tensor,
+    beta: float = 0.0,
+    C: Optional[torch.Tensor] = None,
+    transA: bool = False,
+    transB: bool = False,
+) -> torch.Tensor:
+    """General matrix multiply: C = alpha * op(A) @ op(B) + beta * C
+
+    op(X) = X if trans=False, X^T if trans=True.
+
+    This is the workhorse for DF-MP2:
+        (ia|P) = Σ_μν C_μi @ (μν|P) @ C_νa    → two GEMMs per aux index
+        B_ia^P = (ia|Q) @ J^{-1/2}_{QP}        → one GEMM
+        E_MP2 = Σ B_ia^P @ B_jb^P              → batched GEMM
+
+    On Trainium, dispatches to NKI GEMM with stationary tile reuse.
+    """
+    from .nki.dispatch import nki_gemm, _use_nki
+
+    a = A.T if transA else A
+    b = B.T if transB else B
+
+    if _use_nki() and a.dim() == 2 and b.dim() == 2:
+        result = alpha * nki_gemm(a, b)
+    else:
+        result = alpha * torch.matmul(a, b)
+
+    if C is not None and beta != 0.0:
+        result = result + beta * C
+
+    return result
+
+
+def batched_gemm(
+    alpha: float,
+    A: torch.Tensor,
+    B: torch.Tensor,
+    beta: float = 0.0,
+    C: Optional[torch.Tensor] = None,
+    transA: bool = False,
+    transB: bool = False,
+) -> torch.Tensor:
+    """Batched GEMM: C[i] = alpha * op(A[i]) @ op(B[i]) + beta * C[i]
+
+    A, B have shape (batch, M, K) and (batch, K, N) respectively.
+
+    Critical for DF-MP2 energy evaluation where contractions are
+    independent across auxiliary basis indices.
+    """
+    a = A.transpose(-2, -1) if transA else A
+    b = B.transpose(-2, -1) if transB else B
+    result = alpha * torch.bmm(a, b)
+    if C is not None and beta != 0.0:
+        result = result + beta * C
+    return result
+
+
+def symm(
+    alpha: float,
+    A: torch.Tensor,
+    B: torch.Tensor,
+    beta: float = 0.0,
+    C: Optional[torch.Tensor] = None,
+    side: str = "left",
+    uplo: str = "upper",
+) -> torch.Tensor:
+    """Symmetric matrix multiply: C = alpha * A @ B + beta * C (side='left')
+                              or C = alpha * B @ A + beta * C (side='right')
+
+    A is symmetric; only upper or lower triangle referenced.
+    Used in Fock matrix construction: F = H_core + J - K
+    where J and K involve symmetric density matrix contractions.
+    """
+    if uplo == "upper":
+        sym = torch.triu(A) + torch.triu(A, diagonal=1).T
+    else:
+        sym = torch.tril(A) + torch.tril(A, diagonal=-1).T
+
+    if side == "left":
+        result = alpha * torch.matmul(sym, B)
+    else:
+        result = alpha * torch.matmul(B, sym)
+
+    if C is not None and beta != 0.0:
+        result = result + beta * C
+    return result
+
+
+def syrk(
+    alpha: float,
+    A: torch.Tensor,
+    beta: float = 0.0,
+    C: Optional[torch.Tensor] = None,
+    trans: bool = False,
+    uplo: str = "upper",
+) -> torch.Tensor:
+    """Symmetric rank-k update: C = alpha * A @ A^T + beta * C  (trans=False)
+                            or C = alpha * A^T @ A + beta * C  (trans=True)
+
+    Used in metric contraction for density fitting:
+    J_{PQ} = Σ_μν (P|μν)(μν|Q) which is A^T @ A form.
+    """
+    if trans:
+        result = alpha * torch.matmul(A.T, A)
+    else:
+        result = alpha * torch.matmul(A, A.T)
+
+    if C is not None and beta != 0.0:
+        result = result + beta * C
+
+    # Symmetrize (numerical stability)
+    result = 0.5 * (result + result.T)
+    return result
+
+
+def trsm(
+    alpha: float,
+    A: torch.Tensor,
+    B: torch.Tensor,
+    side: str = "left",
+    uplo: str = "upper",
+    trans: bool = False,
+    diag: str = "nonunit",
+) -> torch.Tensor:
+    """Triangular solve with multiple RHS: op(A) @ X = alpha * B  (side='left')
+                                       or X @ op(A) = alpha * B  (side='right')
+
+    Returns X.
+
+    Critical for Cholesky-based density fitting:
+    Given J = L @ L^T, solve L @ X = (μν|P) for X,
+    then B_ia^P = C^T @ X gives the DF coefficients.
+    """
+    if uplo == "upper":
+        tri = torch.triu(A)
+    else:
+        tri = torch.tril(A)
+
+    if diag == "unit":
+        tri = tri - torch.diag(torch.diag(tri)) + torch.eye(A.shape[0], dtype=A.dtype, device=A.device)
+
+    mat = tri.T if trans else tri
+
+    if side == "left":
+        # Solve mat @ X = alpha * B
+        return alpha * torch.linalg.solve_triangular(mat, B, upper=(uplo == "upper" and not trans) or (uplo == "lower" and trans))
+    else:
+        # Solve X @ mat = alpha * B  →  mat^T @ X^T = alpha * B^T
+        upper_flag = (uplo == "lower" and not trans) or (uplo == "upper" and trans)
+        return alpha * torch.linalg.solve_triangular(mat.T, B.T, upper=upper_flag).T
+
+
+def trmm(
+    alpha: float,
+    A: torch.Tensor,
+    B: torch.Tensor,
+    side: str = "left",
+    uplo: str = "upper",
+    trans: bool = False,
+    diag: str = "nonunit",
+) -> torch.Tensor:
+    """Triangular matrix multiply: B = alpha * op(A) @ B  (side='left')
+                               or B = alpha * B @ op(A)  (side='right')
+    """
+    if uplo == "upper":
+        tri = torch.triu(A)
+    else:
+        tri = torch.tril(A)
+
+    if diag == "unit":
+        tri = tri - torch.diag(torch.diag(tri)) + torch.eye(A.shape[0], dtype=A.dtype, device=A.device)
+
+    mat = tri.T if trans else tri
+
+    if side == "left":
+        return alpha * torch.matmul(mat, B)
+    else:
+        return alpha * torch.matmul(B, mat)

trnblas/nki/__init__.py

@@ -0,0 +1,5 @@
+"""NKI kernel dispatch for Trainium BLAS acceleration."""
+
+from .dispatch import HAS_NKI, set_backend, get_backend, nki_gemm
+
+__all__ = ["HAS_NKI", "set_backend", "get_backend", "nki_gemm"]

trnblas/nki/dispatch.py

@@ -0,0 +1,121 @@
+"""
+NKI dispatch for BLAS operations.
+
+Backend selection mirrors trnfft: auto/pytorch/nki.
+The GEMM kernel is the primary acceleration target — it uses stationary
+tile reuse on the Tensor Engine for 2x fewer SBUF loads vs naive.
+"""
+
+from __future__ import annotations
+
+import torch
+
+try:
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.isa as nisa
+    HAS_NKI = True
+except ImportError:
+    HAS_NKI = False
+
+_backend = "auto"
+
+
+def set_backend(backend: str):
+    global _backend
+    assert backend in ("auto", "pytorch", "nki")
+    if backend == "nki" and not HAS_NKI:
+        raise RuntimeError("NKI backend requires neuronxcc")
+    _backend = backend
+
+
+def get_backend() -> str:
+    return _backend
+
+
+def _use_nki() -> bool:
+    if _backend == "nki":
+        return True
+    if _backend == "pytorch":
+        return False
+    return HAS_NKI
+
+
+def nki_gemm(A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:
+    """GEMM with NKI dispatch.
+
+    On NKI backend: uses tiled GEMM with stationary A reuse.
+    On PyTorch backend: torch.matmul.
+
+    NKI GEMM strategy (stationary tile reuse):
+        1. Load A tile to SBUF as stationary (stays in systolic array)
+        2. Stream B tiles as moving → accumulate in PSUM
+        3. One A load serves multiple B tiles
+
+    For DF-MP2 tensor contractions where A is the MO coefficient matrix
+    (reused across auxiliary basis indices), this cuts SBUF loads in half.
+    """
+    if _use_nki():
+        return _nki_gemm_impl(A, B)
+    return torch.matmul(A, B)
+
+
+def _nki_gemm_impl(A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:
+    """NKI GEMM implementation.
+
+    TODO: Wire to actual NKI kernel with tiling once validated on trn1/trn2.
+    The kernel should:
+    - Tile A into 128×128 blocks (SBUF capacity)
+    - For each A tile, stream all corresponding B tiles through the systolic array
+    - Accumulate partial products in PSUM
+    - Handle edge tiles for non-128-aligned dimensions
+
+    See neuron-complex-ops kernels_optimized.py for the complex variant
+    of this pattern — real GEMM is simpler (no real/imag split needed).
+    """
+    if not HAS_NKI:
+        raise RuntimeError("NKI not available")
+    # Fallback until kernel is validated on hardware
+    return torch.matmul(A, B)
+
+
+if HAS_NKI:
+
+    @nki.jit
+    def gemm_kernel(A_ref, B_ref, C_ref, M: int, N: int, K: int):
+        """Tiled GEMM kernel for Trainium NeuronCore.
+
+        C[M,N] = A[M,K] @ B[K,N]
+
+        Tiling: 128×128 tiles for SBUF, accumulate in PSUM.
+        A tiles are stationary (loaded once, reused across N tiles).
+        B tiles are streamed (moving operand in systolic array).
+
+        STUB: Scaffolded for on-hardware validation.
+        """
+        TILE = 128
+
+        for m_tile in nl.affine_range(M // TILE):
+            for k_tile in nl.affine_range(K // TILE):
+                # Load A tile — stationary in systolic array
+                a_tile = nl.load(
+                    A_ref[m_tile * TILE:(m_tile + 1) * TILE,
+                          k_tile * TILE:(k_tile + 1) * TILE]
+                )
+
+                for n_tile in nl.affine_range(N // TILE):
+                    # Stream B tile — moving operand
+                    b_tile = nl.load(
+                        B_ref[k_tile * TILE:(k_tile + 1) * TILE,
+                              n_tile * TILE:(n_tile + 1) * TILE]
+                    )
+
+                    # Matmul → accumulate in PSUM
+                    c_partial = nisa.nc_matmul(a_tile, b_tile)
+
+                    # Store (would accumulate across k_tiles in practice)
+                    nl.store(
+                        C_ref[m_tile * TILE:(m_tile + 1) * TILE,
+                              n_tile * TILE:(n_tile + 1) * TILE],
+                        c_partial
+                    )

trnblas-0.2.0.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: trnblas
+Version: 0.2.0
+Summary: BLAS operations for AWS Trainium via NKI
+Author-email: Scott Friedman <scott@playgroundlogic.co>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/scttfrdmn/trnblas
+Project-URL: Repository, https://github.com/scttfrdmn/trnblas
+Project-URL: Issues, https://github.com/scttfrdmn/trnblas/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.1
+Requires-Dist: numpy>=1.24
+Provides-Extra: neuron
+Requires-Dist: neuronxcc>=2.15; extra == "neuron"
+Requires-Dist: torch-neuronx>=2.1; extra == "neuron"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-benchmark>=4.0; extra == "dev"
+Requires-Dist: scipy>=1.11; extra == "dev"
+Dynamic: license-file
+
+# trnblas
+
+[![CI](https://github.com/scttfrdmn/trnblas/actions/workflows/ci.yml/badge.svg)](https://github.com/scttfrdmn/trnblas/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/trnblas)](https://pypi.org/project/trnblas/)
+[![Python](https://img.shields.io/pypi/pyversions/trnblas)](https://pypi.org/project/trnblas/)
+[![License](https://img.shields.io/github/license/scttfrdmn/trnblas)](LICENSE)
+[![Docs](https://img.shields.io/badge/docs-mkdocs-blue)](https://scttfrdmn.github.io/trnblas/)
+
+BLAS operations for AWS Trainium via NKI (Neuron Kernel Interface).
+
+Trainium ships no BLAS library. `trnblas` provides Level 1-3 BLAS operations with NKI kernel acceleration on the Tensor Engine, targeting scientific computing workloads that are GEMM-dominated.
+
+Part of the **trn-\*** scientific computing suite by [Playground Logic](https://playgroundlogic.co).
+
+## Why
+
+NVIDIA has cuBLAS with 152 optimized routines. Trainium has `torch.matmul`. That's fine for ML training but insufficient for scientific computing codes that need TRSM, SYRK, SYMM, and batched GEMM with specific transpose/scaling semantics.
+
+trnblas closes this gap — same BLAS API surface, NKI-accelerated GEMM on Trainium, PyTorch fallback everywhere else.
+
+## Install
+
+```bash
+pip install trnblas
+
+# With Neuron hardware support
+pip install trnblas[neuron]
+```
+
+## Usage
+
+```python
+import torch
+import trnblas
+
+# Level 3 — Matrix multiply (the hot path)
+C = trnblas.gemm(alpha=1.0, A=A, B=B, beta=0.5, C=C_init, transA=True)
+
+# Batched GEMM (DF-MP2 tensor contractions)
+C = trnblas.batched_gemm(1.0, A_batch, B_batch)
+
+# Symmetric matrix multiply (Fock builds)
+F = trnblas.symm(1.0, density, H_core, side="left")
+
+# Triangular solve (Cholesky-based density fitting)
+X = trnblas.trsm(1.0, L, B, uplo="lower")
+
+# Symmetric rank-k update (metric construction)
+J = trnblas.syrk(1.0, integrals, trans=True)
+
+# Level 2 — Matrix-vector
+y = trnblas.gemv(1.0, A, x, beta=1.0, y=y)
+
+# Level 1 — Vector operations
+y = trnblas.axpy(alpha, x, y)
+d = trnblas.dot(x, y)
+n = trnblas.nrm2(x)
+```
+
+## DF-MP2 Example
+
+```bash
+# Run the density-fitted MP2 example (Janesko/TCU use case)
+python examples/df_mp2.py --demo
+python examples/df_mp2.py --nbasis 100 --nocc 20
+```
+
+The example demonstrates all core BLAS operations in a realistic quantum chemistry workflow: Cholesky factorization, triangular solve, half-transform GEMMs, metric contraction, and energy evaluation.
+
+## Operations
+
+| Level | Operation | Description |
+|-------|-----------|-------------|
+| 1 | `axpy` | y = αx + y |
+| 1 | `dot` | x^T y |
+| 1 | `nrm2` | ‖x‖₂ |
+| 1 | `scal` | x = αx |
+| 1 | `asum` | Σ\|xᵢ\| |
+| 1 | `iamax` | argmax \|xᵢ\| |
+| 2 | `gemv` | y = α op(A) x + βy |
+| 2 | `symv` | y = α A x + βy (A symmetric) |
+| 2 | `trmv` | x = op(A) x (A triangular) |
+| 2 | `ger` | A = α x yᵀ + A |
+| 3 | `gemm` | C = α op(A) op(B) + βC |
+| 3 | `batched_gemm` | Batched GEMM |
+| 3 | `symm` | C = α A B + βC (A symmetric) |
+| 3 | `syrk` | C = α A Aᵀ + βC |
+| 3 | `trsm` | Solve op(A) X = αB |
+| 3 | `trmm` | B = α op(A) B |
+
+## Status
+
+- [x] Level 1-3 BLAS with PyTorch backend
+- [x] GEMM with NKI dispatch stub
+- [x] DF-MP2 example (Janesko/TCU use case)
+- [ ] NKI GEMM kernel validation on trn1/trn2
+- [ ] NKI GEMM with stationary tile reuse
+- [ ] Batched GEMM NKI kernel
+- [ ] Double-double FP64 emulation
+- [ ] Benchmarks vs cuBLAS
+
+## Related Projects
+
+| Project | What |
+|---------|------|
+| [trnfft](https://github.com/scttfrdmn/trnfft) | FFT + complex ops for Trainium (Williamson/OSU use case) |
+| trnsolver *(planned)* | Linear solvers and eigendecomposition |
+
+## License
+
+Apache 2.0 — Playground Logic LLC

trnblas-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+trnblas/__init__.py,sha256=ZKCqCn3hyUm6zMdkdvjziyf6rdAte84ggrmzWp20WIc,1043
+trnblas/level1.py,sha256=3XVIacU0ZJkF5lTYuN-j4AU-2p9ZqCV7uGZXLn4S-h0,1044
+trnblas/level2.py,sha256=pbdxD1Dh37Whga7f1foVUIrmIq8lN_y3LKBX-VGh-c8,2059
+trnblas/level3.py,sha256=k6dCFMsJCs8sj38GfWGmVBkMuaKkDYU03vfTCr3nBYQ,5782
+trnblas/nki/__init__.py,sha256=IOVhXRydqjqRG2XHYGqqSA9wuyGQAN-IclX0mDPmVik,190
+trnblas/nki/dispatch.py,sha256=qDdEdQ1MQZKkt1GvghNpFzRZWM3YcSkBeqaBTUdOVv8,3815
+trnblas-0.2.0.dist-info/licenses/LICENSE,sha256=56AI7gGqh5OTpJf3y7nJVeWAY67dDH3l_CsDmdRYRog,749
+trnblas-0.2.0.dist-info/METADATA,sha256=ua4gNkBef_tnxPvRqrGpQrr8tbgDbE-Xv02p6K0DGdw,4762
+trnblas-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+trnblas-0.2.0.dist-info/top_level.txt,sha256=sUhvzYD9c6aMPJncvKmDoqdSqUy604F-qtzICWbj4SY,8
+trnblas-0.2.0.dist-info/RECORD,,

trnblas-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

trnblas-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 Playground Logic LLC
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

trnblas-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+trnblas