blksprs 2.1.7__py3-none-any.whl → 2.1.8__py3-none-any.whl

blksprs/__init__.py

@@ -1,6 +1,14 @@
-from blksprs.utils.blksprs_tensor import BlksprsTensor
+# Settings
+import torch
+
+# Capture scalar outputs for JIT compilation
+torch._dynamo.config.capture_scalar_outputs = True
+# Set version
+__version__ = "2.1.8"
 
-__version__ = "2.1.7"
+# Imports
+
+from blksprs.utils.blksprs_tensor import BlksprsTensor
 
 
 class ops:

blksprs/layouting/distribution_layout.py

@@ -7,9 +7,9 @@ from torch._library import triton_op
 from torch._library.triton import wrap_triton
 from triton import language as tl
 
+from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
 from blksprs.utils.blksprs_tensor import BlksprsTensor
 from blksprs.utils.tools import stride
-from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
 from blksprs.utils.validation import validate_dimensions, validate_device, \
     validate_contiguous
 

blksprs/layouting/sparsity_layout.py

@@ -6,9 +6,9 @@ from torch import Tensor
 from torch._library.triton import wrap_triton, triton_op
 from triton import language as tl
 
+from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs, prune_autotune_configs_conversion
 from blksprs.utils.blksprs_tensor import BlksprsTensor
 from blksprs.utils.tools import stride
-from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs, prune_autotune_configs_conversion
 from blksprs.utils.validation import validate_dimensions, validate_device, \
     validate_contiguous, validate_sparsity, validate_sparsity_block_size
 

blksprs/ops/conversion.py

@@ -5,9 +5,9 @@ from torch._library.triton import wrap_triton, triton_op
 from triton import language as tl
 
 from blksprs.layouting.sparsity_layout import build_sparsity_layout_adaption
+from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs, prune_autotune_configs_conversion
 from blksprs.utils.blksprs_tensor import BlksprsTensor
 from blksprs.utils.tools import stride
-from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs, prune_autotune_configs_conversion
 from blksprs.utils.validation import validate_contiguous, validate_dimensions, validate_device, \
     validate_sparsity, validate_sparsity_block_size, validate_sparsity_dense, ensure_contiguous
 
@@ -46,10 +46,10 @@ def to_sparse(x: Tensor, sparsity_layout: Tensor,
     lut = to_sparse_build_lut(lut, sparsity_layout)
 
     if sparsity_layout.size(1) == 1 and sparsity_layout.size(2) == 1 and torch.all(sparsity_layout):
-        return BlksprsTensor(x)
+        return BlksprsTensor.wrap(x)
 
-    return BlksprsTensor(to_sparse_forward(x, sparsity_layout,
-                                           lut["sparsity_lut"], sparsity_block_size, lut["n_sparse_blocks"]))
+    return BlksprsTensor.wrap(to_sparse_forward(x, sparsity_layout,
+                                                lut["sparsity_lut"], sparsity_block_size, lut["n_sparse_blocks"]))
 
 
 @triton_op("blksprs::to_sparse_forward", mutates_args={})
@@ -201,7 +201,7 @@ def to_dense(x: BlksprsTensor, sparsity_layout: Tensor,
         return x
 
     return Tensor(to_dense_forward(x, sparsity_layout,
-                            lut["sparsity_reverse_lut"], sparsity_block_size, fill_value))
+                                   lut["sparsity_reverse_lut"], sparsity_block_size, fill_value))
 
 
 @triton_op("blksprs::to_dense_forward", mutates_args={})
@@ -360,14 +360,14 @@ def adapt_layout(x: BlksprsTensor, sparsity_layout_from: Tensor, sparsity_block_
     validate_contiguous(sparsity_reverse_lut_from, sparsity_layout_to, sparsity_lut_to)
 
     if (sparsity_block_size_from == sparsity_block_size_to) and torch.equal(sparsity_layout_from, sparsity_layout_to):
-        return BlksprsTensor(x), sparsity_layout_to
-
-    return BlksprsTensor(adapt_layout_forward(x,
-                                              sparsity_layout_from, sparsity_reverse_lut_from,
-                                              sparsity_block_size_from,
-                                              sparsity_layout_to, sparsity_lut_to,
-                                              sparsity_block_size_to,
-                                              n_sparse_blocks_to)), sparsity_layout_to
+        return BlksprsTensor.wrap(x), sparsity_layout_to
+
+    return BlksprsTensor.wrap(adapt_layout_forward(x,
+                                                   sparsity_layout_from, sparsity_reverse_lut_from,
+                                                   sparsity_block_size_from,
+                                                   sparsity_layout_to, sparsity_lut_to,
+                                                   sparsity_block_size_to,
+                                                   n_sparse_blocks_to)), sparsity_layout_to
 
 
 @triton_op("blksprs::adapt_layout_forward", mutates_args={})

blksprs/ops/distribution.py

@@ -5,9 +5,9 @@ from torch._library import triton_op
 from torch._library.triton import wrap_triton
 from triton import language as tl
 
+from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
 from blksprs.utils.blksprs_tensor import BlksprsTensor
 from blksprs.utils.tools import stride
-from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
 from blksprs.utils.validation import validate_contiguous, validate_dimensions, validate_device, \
     validate_sparsity, validate_dtype_int, validate_sparsity_block_size, ensure_contiguous
 
@@ -45,9 +45,9 @@ def gather(src: BlksprsTensor, sparsity_layout_src: Tensor,
 
     lut = gather_build_lut(lut, sparsity_layout_src, sparsity_layout_idx)
 
-    return BlksprsTensor(gather_forward(src, sparsity_layout_src, lut["sparsity_reverse_lut_x"],
-                                        adjusted_dim, idx, sparsity_layout_idx, lut["sparsity_lut_i"],
-                                        sparsity_block_size))
+    return BlksprsTensor.wrap(gather_forward(src, sparsity_layout_src, lut["sparsity_reverse_lut_x"],
+                                             adjusted_dim, idx, sparsity_layout_idx, lut["sparsity_lut_i"],
+                                             sparsity_block_size))
 
 
 @triton_op("blksprs::gather_forward", mutates_args={})
@@ -276,11 +276,11 @@ def scatter_reduce(src: BlksprsTensor, sparsity_layout_src: Tensor,
 
     lut = scatter_reduce_build_lut(lut, sparsity_layout_src, sparsity_layout_tgt)
 
-    return BlksprsTensor(scatter_reduce_forward(src, sparsity_layout_src, lut["sparsity_lut_x"],
-                                                adjusted_dim, idx,
-                                                sparsity_layout_tgt, lut["sparsity_reverse_lut_o"],
-                                                sparsity_block_size, lut["n_sparse_blocks"],
-                                                reduce_op))
+    return BlksprsTensor.wrap(scatter_reduce_forward(src, sparsity_layout_src, lut["sparsity_lut_x"],
+                                                     adjusted_dim, idx,
+                                                     sparsity_layout_tgt, lut["sparsity_reverse_lut_o"],
+                                                     sparsity_block_size, lut["n_sparse_blocks"],
+                                                     reduce_op))
 
 
 @triton_op("blksprs::scatter_reduce_forward", mutates_args={})

blksprs/ops/flow.py

@@ -5,8 +5,8 @@ from torch._library import triton_op
 from torch._library.triton import wrap_triton
 from triton import language as tl
 
-from blksprs.utils.tools import stride
 from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
+from blksprs.utils.tools import stride
 
 
 @triton_op("blksprs::flow_pull_forward", mutates_args={})

blksprs/ops/matmul.py

@@ -5,9 +5,9 @@ from torch.library import triton_op, wrap_triton
 from triton import language as tl
 
 from blksprs.ops.transpose import transpose
+from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
 from blksprs.utils.blksprs_tensor import BlksprsTensor
 from blksprs.utils.tools import stride
-from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
 from blksprs.utils.validation import validate_contiguous, validate_dimensions, validate_device, \
     validate_sparsity, validate_sparsity_block_size, validate_dtype_float, ensure_contiguous
 
@@ -47,11 +47,11 @@ def matmul(x: BlksprsTensor, sparsity_layout_x: Tensor,
 
     lut = matmul_build_lut(lut, sparsity_layout_x, sparsity_layout_y, sparsity_layout_output)
 
-    return BlksprsTensor(matmul_forward(x, y,
-                                        sparsity_layout_x, lut["sparsity_reverse_lut_x"],
-                                        sparsity_layout_y, lut["sparsity_reverse_lut_y"],
-                                        sparsity_layout_output, lut["sparsity_lut_o"],
-                                        sparsity_block_size, lut["n_sparse_blocks"]))
+    return BlksprsTensor.wrap(matmul_forward(x, y,
+                                             sparsity_layout_x, lut["sparsity_reverse_lut_x"],
+                                             sparsity_layout_y, lut["sparsity_reverse_lut_y"],
+                                             sparsity_layout_output, lut["sparsity_lut_o"],
+                                             sparsity_block_size, lut["n_sparse_blocks"]))
 
 
 @triton_op("blksprs::matmul_forward", mutates_args={})

blksprs/ops/misc/broadcast_ops.py

@@ -5,9 +5,9 @@ from torch._library import triton_op
 from torch._library.triton import wrap_triton
 from triton import language as tl
 
+from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
 from blksprs.utils.blksprs_tensor import BlksprsTensor
 from blksprs.utils.tools import stride
-from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
 from blksprs.utils.validation import validate_contiguous, validate_device, \
     validate_sparsity_block_size, ensure_contiguous
 
@@ -43,7 +43,7 @@ def broadcast_add(x: Tensor, y: Tensor, sparsity_layout_output: Tensor,
 
     validate_contiguous(sparsity_layout_output, sparsity_lut_o)
 
-    return BlksprsTensor(broadcast_add_forward(x, y, sparsity_lut_o, sparsity_block_size, n_sparse_blocks))
+    return BlksprsTensor.wrap(broadcast_add_forward(x, y, sparsity_lut_o, sparsity_block_size, n_sparse_blocks))
 
 
 def broadcast_sub(x: Tensor, y: Tensor, sparsity_layout_output: Tensor,

blksprs/ops/misc/row_wise.py

@@ -55,7 +55,7 @@ def row_wise_sum(x: BlksprsTensor, sparsity_layout: Tensor, sparsity_block_size:
     validate_contiguous(sparsity_layout, sparsity_lut,
                         sparsity_layout_output, sparsity_reverse_lut_output)
 
-    return BlksprsTensor(row_wise_sum_forward(
+    return BlksprsTensor.wrap(row_wise_sum_forward(
         x, sparsity_lut, sparsity_layout_output, sparsity_reverse_lut_output,
         sparsity_block_size, n_sparse_blocks_output, flag_slice_only)), sparsity_layout_output
 
@@ -174,8 +174,6 @@ def row_wise_max(x: BlksprsTensor, sparsity_layout: Tensor, sparsity_block_size:
             of the input and the sparsity layout of the output tensor.
 
     """
-    # TODO Fix for triton bug, see https://github.com/triton-lang/triton/issues/6376, should be fixed with the upcoming 3.4.0 release
-    x = torch.where(x == -0.0, torch.tensor(0.0), x)
     x = ensure_contiguous(x)
 
     validate_dimensions(x)
@@ -197,7 +195,7 @@ def row_wise_max(x: BlksprsTensor, sparsity_layout: Tensor, sparsity_block_size:
     validate_contiguous(sparsity_layout, sparsity_lut,
                         sparsity_layout_output, sparsity_reverse_lut_output)
 
-    return BlksprsTensor(
+    return BlksprsTensor.wrap(
         row_wise_max_forward(x, sparsity_lut, sparsity_layout_output, sparsity_reverse_lut_output, sparsity_block_size,
                              n_sparse_blocks_output, flag_slice_only)), sparsity_layout_output
 
@@ -329,8 +327,8 @@ def row_wise_add(x: BlksprsTensor, sparsity_layout_x: Tensor, y: Tensor,
 
     validate_contiguous(sparsity_layout_x, sparsity_lut_x, sparsity_reverse_lut_rwm)
 
-    return BlksprsTensor(row_wise_add_forward(x, sparsity_lut_x, sparsity_layout_rwm,
-                                              sparsity_reverse_lut_rwm, y, sparsity_block_size))
+    return BlksprsTensor.wrap(row_wise_add_forward(x, sparsity_lut_x, sparsity_layout_rwm,
+                                                   sparsity_reverse_lut_rwm, y, sparsity_block_size))
 
 
 def row_wise_sub(x: BlksprsTensor, sparsity_layout_x: Tensor, y: Tensor,

blksprs/ops/partitioning.py

@@ -41,7 +41,7 @@ def split(x: BlksprsTensor, sparsity_layout: Tensor, partitions: int,
 
     lut = split_build_lut(lut, sparsity_layout, partitions)
 
-    return BlksprsTensor(split_forward(
+    return BlksprsTensor.wrap(split_forward(
         x, lut["sparsity_layout_output"], lut["sparsity_lut"], lut["sparsity_reverse_lut"],
         partitions, adjusted_dim, sparsity_block_size, lut["n_sparse_blocks"])), lut["sparsity_layout_output"]
 
@@ -146,7 +146,7 @@ def merge(x: BlksprsTensor, sparsity_layout: Tensor, partitions: int,
 
     lut = merge_build_lut(lut, sparsity_layout, partitions)
 
-    return BlksprsTensor(merge_forward(
+    return BlksprsTensor.wrap(merge_forward(
         x, lut["sparsity_layout_output"], lut["sparsity_lut"], lut["sparsity_reverse_lut"],
         partitions, adjusted_dim, sparsity_block_size, lut["n_sparse_blocks"])), lut["sparsity_layout_output"]
 

blksprs/ops/repeat.py

@@ -46,7 +46,7 @@ def repeat(x: BlksprsTensor, sparsity_layout_x: Tensor, repeats: tuple[int, int,
 
     lut = repeat_build_lut(lut, sparsity_layout_x, repeats, sparsity_layout_output)
 
-    return BlksprsTensor(repeat_forward(
+    return BlksprsTensor.wrap(repeat_forward(
         x, sparsity_layout_x, lut["sparsity_layout_o"], lut["sparsity_lut"],
         lut["sparsity_reverse_lut"], sparsity_block_size, lut["n_sparse_blocks"])), lut["sparsity_layout_o"]
 
@@ -87,7 +87,7 @@ def repeat_interleave(x: BlksprsTensor, sparsity_layout_x: Tensor, repeats: int,
 
     lut = repeat_interleave_build_lut(lut, sparsity_layout_x, repeats, sparsity_layout_output)
 
-    return BlksprsTensor(repeat_forward(
+    return BlksprsTensor.wrap(repeat_forward(
         x, sparsity_layout_x, lut["sparsity_layout_o"], lut["sparsity_lut"],
         lut["sparsity_reverse_lut"], sparsity_block_size, lut["n_sparse_blocks"])), lut["sparsity_layout_o"]
 

blksprs/ops/softmax.py

@@ -1,5 +1,3 @@
-import pdb
-
 import torch
 import triton
 from torch import Tensor
@@ -8,9 +6,9 @@ from torch._library.triton import wrap_triton
 from triton import language as tl
 
 from blksprs.ops.misc.row_wise import row_wise_sum, row_wise_max, row_wise_sub
+from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
 from blksprs.utils.blksprs_tensor import BlksprsTensor
 from blksprs.utils.tools import stride, ceil_pow2
-from blksprs.utils.autotuning import get_autotune_configs, prune_autotune_configs
 from blksprs.utils.validation import validate_contiguous, validate_dimensions, validate_device, \
     validate_sparsity, validate_sparsity_block_size, validate_dtype_float_32, ensure_contiguous
 
@@ -55,10 +53,10 @@ def softmax_regular(x: BlksprsTensor, sparsity_layout: Tensor, sparsity_block_si
 
     lut = softmax_build_lut(lut, sparsity_layout)
 
-    return BlksprsTensor(softmax_forward(x, sparsity_layout,
-                                         lut["sparsity_lut"],
-                                         lut["sparsity_reverse_lut_rws"],
-                                         sparsity_block_size))
+    return BlksprsTensor.wrap(softmax_forward(x, sparsity_layout,
+                                              lut["sparsity_lut"],
+                                              lut["sparsity_reverse_lut_rws"],
+                                              sparsity_block_size))
 
 
 @triton_op("blksprs::softmax_forward", mutates_args={})
@@ -346,10 +344,10 @@ def softmax_fused(x: BlksprsTensor, sparsity_layout: Tensor, sparsity_block_size
 
     lut = softmax_fused_build_lut(lut, sparsity_layout)
 
-    return BlksprsTensor(softmax_fused_forward(x, sparsity_layout,
-                                               lut["sparsity_reverse_lut_sorted"],
-                                               lut["max_blocks_line"],
-                                               sparsity_block_size))
+    return BlksprsTensor.wrap(softmax_fused_forward(x, sparsity_layout,
+                                                    lut["sparsity_reverse_lut_sorted"],
+                                                    lut["max_blocks_line"],
+                                                    sparsity_block_size))
 
 
 @triton_op("blksprs::softmax_fused_forward", mutates_args={})

blksprs/ops/transpose.py

@@ -37,9 +37,9 @@ def transpose(x: BlksprsTensor, sparsity_layout: Tensor,
 
     lut = transpose_build_lut(lut, sparsity_layout)
 
-    return BlksprsTensor(transpose_forward(x, lut["sparsity_layout_t"],
-                                           lut["sparsity_lut"], lut["sparsity_reverse_lut"],
-                                           sparsity_block_size, lut["n_sparse_blocks"])), lut["sparsity_layout_t"]
+    return BlksprsTensor.wrap(transpose_forward(x, lut["sparsity_layout_t"],
+                                                lut["sparsity_lut"], lut["sparsity_reverse_lut"],
+                                                sparsity_block_size, lut["n_sparse_blocks"])), lut["sparsity_layout_t"]
 
 
 @triton_op("blksprs::transpose_forward", mutates_args={})

blksprs/utils/autotuning.py

@@ -75,4 +75,4 @@ def get_autotune_configs():
         autotune_configs.append(
             triton.Config({"TRITON_BLOCK_SIZE": block_size}, num_stages=num_stages, num_warps=num_warps))
 
-    return autotune_configs
+    return autotune_configs

blksprs/utils/blksprs_tensor.py

@@ -1,3 +1,5 @@
+from typing import Union
+
 import torch
 from torch import Tensor
 
@@ -7,4 +9,11 @@ class BlksprsTensor(Tensor):
     """
 
     def __repr__(self):
-        return f"BlksprsTensor({torch.Tensor(self).__repr__()})"
+        return f"BlksprsTensor({torch.Tensor(self).__repr__()})"
+
+    @staticmethod
+    def wrap(tensor: Tensor) -> Union[Tensor, "BlksprsTensor"]:
+        if torch._dynamo.is_compiling():
+            return tensor
+        else:
+            return BlksprsTensor(tensor)

blksprs/utils/processing.py

@@ -26,7 +26,8 @@ def apply_torch_linear(x: BlksprsTensor, sparsity_layout: Tensor, sparsity_block
 
     # Apply weights
     sparsity_layout_xw = build_sparsity_layout_matmul_fast(sparsity_layout, sparsity_layout_w_t)
-    xw = matmul(x, sparsity_layout, BlksprsTensor(w_t_bs.to(x.dtype)), sparsity_layout_w_t, sparsity_layout_xw, sparsity_block_size)
+    xw = matmul(x, sparsity_layout, BlksprsTensor.wrap(w_t_bs.to(x.dtype)), sparsity_layout_w_t, sparsity_layout_xw,
+                sparsity_block_size)
     interim = xw
 
     # Apply bias

blksprs/utils/tools.py

@@ -1,9 +1,5 @@
-import torch
 from torch import Tensor, Size
 
-# Capture scalar outputs for JIT compilation
-torch._dynamo.config.capture_scalar_outputs = True
-
 
 def do_shape_blocksparse(x: Tensor) -> tuple[Tensor, Size]:
     if x.dim() == 3:
@@ -27,7 +23,8 @@ def stride(x: Tensor):
     else:
         raise NotImplementedError
 
+
 def ceil_pow2(x: int) -> int:
     if x <= 0:
         raise ValueError("Input must be a positive integer.")
-    return 1 << (x - 1).bit_length()
+    return 1 << (x - 1).bit_length()

{blksprs-2.1.7.dist-info → blksprs-2.1.8.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: blksprs
-Version: 2.1.7
+Version: 2.1.8
 Summary: A lightweight library for operations on block-sparse matrices in PyTorch.
 Author-email: Felix Schön <schoen@kr.tuwien.ac.at>
 Project-URL: Homepage, https://github.com/FelixSchoen/blksprs
 Project-URL: Bugtracker, https://github.com/FelixSchoen/blksprs/issues
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: torch
+Requires-Dist: torch>=2.8.0
 Requires-Dist: numpy
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"

blksprs-2.1.8.dist-info/RECORD

@@ -0,0 +1,23 @@
+blksprs/__init__.py,sha256=JoMjkaouJY54Z0v85diwErpJRnT9fFIH1wQvg0djOME,1777
+blksprs/layouting/distribution_layout.py,sha256=GtiJH0IcIQodWZnkXqo7ZQ0TLl1HJe30eSuMs86CKPg,5861
+blksprs/layouting/sparsity_layout.py,sha256=hsgXUbPYfLVTjHUwXyMEx2XrbF0OqUWbUg07KKsQG_g,11207
+blksprs/ops/conversion.py,sha256=6gXHMnkh1-XzjnjCorDBNTANcEWM6hbTRsI9e-VRWjw,21462
+blksprs/ops/distribution.py,sha256=9s2V78Og_p7BvTqWm3jW-7ep_0hfcmZtkDtF7HBEUU4,20220
+blksprs/ops/flow.py,sha256=ziR3q1Da25k6xcFhlks1BWzzuOvJxvO_Bm9XZNuyJJQ,7760
+blksprs/ops/matmul.py,sha256=_bF357SM_38JTIaZih9yXSbFjfmHU2cMCyXj4aseKFE,11609
+blksprs/ops/partitioning.py,sha256=88TU77uDbvZTcYdTah9oChJrbgqZdkj4tNPylf9IS1c,9995
+blksprs/ops/repeat.py,sha256=2Ilr0qf0Glow-lNwxV0mW5iuKPT8Dt10D0tpOOe5EGs,9090
+blksprs/ops/softmax.py,sha256=LMrkef7OxMhd6eclj6975KAAklFT2hm7h_0ewjYgHx4,23498
+blksprs/ops/transpose.py,sha256=IaNdqWDZ2rNSaO8kwpQyoSUpVpsoxMREgEXzhVBTsaY,4112
+blksprs/ops/misc/broadcast_ops.py,sha256=iosw2dsbvEVmq3THP3vZ98_NqtAf9P_u5nTXFmf3sLA,5697
+blksprs/ops/misc/row_wise.py,sha256=ldfdy9h_ERhCtJJvu4tXr9tqkNB5QoiSa7NUNo2MQgA,19253
+blksprs/utils/autotuning.py,sha256=SOvVesXmVDbAprKtVGlfqKQ-JyRHfynvxtsbH7Qjem0,2053
+blksprs/utils/benchmarking.py,sha256=dLabDscTFn5NkmOI1g7DnKeTneUYW3RIVv9MDF-8BKc,1271
+blksprs/utils/blksprs_tensor.py,sha256=Y8YnsFPifvdCf5Khsm8bDVv-589U0N8IsCFlnDETfzE,476
+blksprs/utils/processing.py,sha256=GcsUl54DDrEoZ0iuWZV5Q0BR2ZML3jWOhypOMxDCsrs,3759
+blksprs/utils/tools.py,sha256=vlIH89TzMxotKeqts0Pipr09uf0HDQN9oQYGSGfAdk4,751
+blksprs/utils/validation.py,sha256=P98sCk6PZCQB0wO3scGTJIXfkv5EpHFM_uNHBXr42n4,4844
+blksprs-2.1.8.dist-info/METADATA,sha256=Yb0YfVMqDLx9PfPBaPfTsrCAe20X-sZWgz2AuniK-Hg,9597
+blksprs-2.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+blksprs-2.1.8.dist-info/top_level.txt,sha256=qyp0IHeY3H2GQA97i4hk_To5rRBS2YcE1HRPSLy04fk,8
+blksprs-2.1.8.dist-info/RECORD,,

blksprs-2.1.7.dist-info/RECORD

@@ -1,23 +0,0 @@
-blksprs/__init__.py,sha256=Kq4YytK5Im-70RGrH1hj39qgc77tL_DH0Gc3KpZgijQ,1631
-blksprs/layouting/distribution_layout.py,sha256=ur1ty_2U-Hfj78hMWsLZvu7ZuGhzW3qGLKMc72DfTZM,5861
-blksprs/layouting/sparsity_layout.py,sha256=eXHmu2h7K5Q-YUpfOxocJoeP_5ZoQFZf_eHLxRZQbYU,11207
-blksprs/ops/conversion.py,sha256=NcBxWWWzMkjQx_fEfh14RWt688X6J82FzDqByAd3Pj4,21405
-blksprs/ops/distribution.py,sha256=pabgyw0m3A4A0osfnOoKffk-b2BKXCn-lC6BU26ocKY,20180
-blksprs/ops/flow.py,sha256=JEGES5ZbMqxR02rwi2Ym4j3VDxkcRxhFO1f-5nNUlM8,7760
-blksprs/ops/matmul.py,sha256=9XPsKbYBw0cdmZY6i4T3Phbx00LXIuA6KI0EIcyGo9U,11584
-blksprs/ops/partitioning.py,sha256=67_a9a5ZpsRmB4BVTOks0stFWp34cb0nk28zQFkXEZc,9985
-blksprs/ops/repeat.py,sha256=Eo7L-TcrrXb_I6xKXLVklp1EuCuA0sfhPaOzw_8y1eU,9080
-blksprs/ops/softmax.py,sha256=YcoZpdC1BdL4zKRQOSjIRtfGgDoQvUZabgNmjbeY8-4,23470
-blksprs/ops/transpose.py,sha256=AyIPuiMAtUAPJPs9eK-Apz6vjZdmnJO9RF6_yH6u6Fk,4097
-blksprs/ops/misc/broadcast_ops.py,sha256=ro7K2ZMOsscxNEp2HY_6efqJ4Wrf-QCFL4NLeDqvah8,5692
-blksprs/ops/misc/row_wise.py,sha256=dfhuXexyFBaNvfZjOt9w3s29ih19JhWIy04_FhUnHgk,19420
-blksprs/utils/autotuning.py,sha256=xalNP3sWdRn8XiVG4jE1-_iy2QhUmIJvTGM83YwgKA0,2052
-blksprs/utils/benchmarking.py,sha256=dLabDscTFn5NkmOI1g7DnKeTneUYW3RIVv9MDF-8BKc,1271
-blksprs/utils/blksprs_tensor.py,sha256=pfoz59aJixj_fIoFx76ySiygwRQUemmgjMKepZ2c4j0,244
-blksprs/utils/processing.py,sha256=RNkEDc0g-sNHRuMPkRzNWU13d3_lIkXMJdoqES4yQTM,3738
-blksprs/utils/tools.py,sha256=TKygEKge4wJtJnXXDg8BTL8vzBpqIJsQ_A3_5FmLpcE,859
-blksprs/utils/validation.py,sha256=P98sCk6PZCQB0wO3scGTJIXfkv5EpHFM_uNHBXr42n4,4844
-blksprs-2.1.7.dist-info/METADATA,sha256=A7ZUYLyq7D8A243kuLSUVu2GKrPEp8-Bi5EYVFgbMdU,9590
-blksprs-2.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-blksprs-2.1.7.dist-info/top_level.txt,sha256=qyp0IHeY3H2GQA97i4hk_To5rRBS2YcE1HRPSLy04fk,8
-blksprs-2.1.7.dist-info/RECORD,,