ztensor 0.1.1__py3-none-musllinux_1_2_armv7l.whl → 0.1.4__py3-none-musllinux_1_2_armv7l.whl

ztensor/__init__.py

@@ -1,6 +1,22 @@
 import numpy as np
 from .ztensor import ffi, lib
-from ml_dtypes import bfloat16
+
+# --- Optional PyTorch Import ---
+try:
+    import torch
+
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+
+# --- Optional ml_dtypes for bfloat16 in NumPy ---
+try:
+    from ml_dtypes import bfloat16 as np_bfloat16
+
+    ML_DTYPES_AVAILABLE = True
+except ImportError:
+    np_bfloat16 = None
+    ML_DTYPES_AVAILABLE = False
 
 
 # --- Pythonic Wrapper ---
@@ -12,7 +28,6 @@ class ZTensorError(Exception):
 # A custom ndarray subclass to safely manage the lifetime of the CFFI pointer.
 class _ZTensorView(np.ndarray):
     def __new__(cls, buffer, dtype, shape, view_ptr):
-        # Create an array from the buffer, reshape it, and cast it to our custom type.
         obj = np.frombuffer(buffer, dtype=dtype).reshape(shape).view(cls)
         # Attach the object that owns the memory to an attribute.
         obj._owner = view_ptr
@@ -45,73 +60,158 @@ def _check_status(status, func_name=""):
         raise ZTensorError(f"Error in {func_name}: {_get_last_error()}")
 
 
-# Type Mappings between NumPy and ztensor
+# --- Type Mappings ---
+# NumPy Mappings
 DTYPE_NP_TO_ZT = {
-    np.dtype('float64'): 'float64', np.dtype('float32'): 'float32',
+    np.dtype('float64'): 'float64', np.dtype('float32'): 'float32', np.dtype('float16'): 'float16',
     np.dtype('int64'): 'int64', np.dtype('int32'): 'int32',
     np.dtype('int16'): 'int16', np.dtype('int8'): 'int8',
     np.dtype('uint64'): 'uint64', np.dtype('uint32'): 'uint32',
     np.dtype('uint16'): 'uint16', np.dtype('uint8'): 'uint8',
     np.dtype('bool'): 'bool',
-    # ADDED: Mapping for bfloat16 to handle writing
-    np.dtype(bfloat16): 'bfloat16',
 }
-# MODIFIED: Re-construct the reverse mapping
+if ML_DTYPES_AVAILABLE:
+    DTYPE_NP_TO_ZT[np.dtype(np_bfloat16)] = 'bfloat16'
 DTYPE_ZT_TO_NP = {v: k for k, v in DTYPE_NP_TO_ZT.items()}
 
+# PyTorch Mappings (if available)
+if TORCH_AVAILABLE:
+    DTYPE_TORCH_TO_ZT = {
+        torch.float64: 'float64', torch.float32: 'float32', torch.float16: 'float16',
+        torch.bfloat16: 'bfloat16',
+        torch.int64: 'int64', torch.int32: 'int32',
+        torch.int16: 'int16', torch.int8: 'int8',
+        torch.uint8: 'uint8', torch.bool: 'bool',
+    }
+    DTYPE_ZT_TO_TORCH = {v: k for k, v in DTYPE_TORCH_TO_ZT.items()}
+
 
 class TensorMetadata:
     """A Pythonic wrapper around the CTensorMetadata pointer."""
 
     def __init__(self, meta_ptr):
-        # The pointer is now automatically garbage collected by CFFI when this object dies.
         self._ptr = ffi.gc(meta_ptr, lib.ztensor_metadata_free)
         _check_ptr(self._ptr, "TensorMetadata constructor")
+        # Cache for properties to avoid repeated FFI calls
         self._name = None
         self._dtype_str = None
         self._shape = None
+        self._offset = None
+        self._size = None
+        self._layout = None
+        self._encoding = None
+        self._endianness = "not_checked"
+        self._checksum = "not_checked"
+
+    def __repr__(self):
+        return f"<TensorMetadata name='{self.name}' shape={self.shape} dtype='{self.dtype_str}'>"
 
     @property
     def name(self):
+        """The name of the tensor."""
         if self._name is None:
             name_ptr = lib.ztensor_metadata_get_name(self._ptr)
             _check_ptr(name_ptr, "get_name")
-            # ffi.string creates a copy, so we must free the Rust-allocated original.
             self._name = ffi.string(name_ptr).decode('utf-8')
             lib.ztensor_free_string(name_ptr)
         return self._name
 
     @property
     def dtype_str(self):
+        """The zTensor dtype string (e.g., 'float32')."""
         if self._dtype_str is None:
             dtype_ptr = lib.ztensor_metadata_get_dtype_str(self._ptr)
             _check_ptr(dtype_ptr, "get_dtype_str")
-            # ffi.string creates a copy, so we must free the Rust-allocated original.
             self._dtype_str = ffi.string(dtype_ptr).decode('utf-8')
             lib.ztensor_free_string(dtype_ptr)
         return self._dtype_str
 
     @property
     def dtype(self):
-        """Returns the numpy dtype for this tensor."""
-        # This will now correctly return a bfloat16 dtype object when dtype_str is 'bfloat16'
-        return DTYPE_ZT_TO_NP.get(self.dtype_str)
+        """The numpy dtype for this tensor."""
+        dtype_str = self.dtype_str
+        dt = DTYPE_ZT_TO_NP.get(dtype_str)
+        if dt is None:
+            if dtype_str == 'bfloat16':
+                raise ZTensorError(
+                    "Cannot read 'bfloat16' tensor as NumPy array because the 'ml_dtypes' "
+                    "package is not installed. Please install it to proceed."
+                )
+            raise ZTensorError(f"Unsupported or unknown dtype string '{dtype_str}' found in tensor metadata.")
+        return dt
 
-    # RE-ENABLED: This property now works because the underlying FFI functions are available.
     @property
     def shape(self):
+        """The shape of the tensor as a tuple."""
         if self._shape is None:
             shape_len = lib.ztensor_metadata_get_shape_len(self._ptr)
             if shape_len > 0:
                 shape_data_ptr = lib.ztensor_metadata_get_shape_data(self._ptr)
                 _check_ptr(shape_data_ptr, "get_shape_data")
                 self._shape = tuple(shape_data_ptr[i] for i in range(shape_len))
-                # Free the array that was allocated on the Rust side.
                 lib.ztensor_free_u64_array(shape_data_ptr, shape_len)
             else:
                 self._shape = tuple()
         return self._shape
 
+    @property
+    def offset(self):
+        """The on-disk offset of the tensor data in bytes."""
+        if self._offset is None:
+            self._offset = lib.ztensor_metadata_get_offset(self._ptr)
+        return self._offset
+
+    @property
+    def size(self):
+        """The on-disk size of the tensor data in bytes (can be compressed size)."""
+        if self._size is None:
+            self._size = lib.ztensor_metadata_get_size(self._ptr)
+        return self._size
+
+    @property
+    def layout(self):
+        """The tensor layout as a string (e.g., 'dense')."""
+        if self._layout is None:
+            layout_ptr = lib.ztensor_metadata_get_layout_str(self._ptr)
+            _check_ptr(layout_ptr, "get_layout_str")
+            self._layout = ffi.string(layout_ptr).decode('utf-8')
+            lib.ztensor_free_string(layout_ptr)
+        return self._layout
+
+    @property
+    def encoding(self):
+        """The tensor encoding as a string (e.g., 'raw', 'zstd')."""
+        if self._encoding is None:
+            encoding_ptr = lib.ztensor_metadata_get_encoding_str(self._ptr)
+            _check_ptr(encoding_ptr, "get_encoding_str")
+            self._encoding = ffi.string(encoding_ptr).decode('utf-8')
+            lib.ztensor_free_string(encoding_ptr)
+        return self._encoding
+
+    @property
+    def endianness(self):
+        """The data endianness ('little', 'big') if applicable, else None."""
+        if self._endianness == "not_checked":
+            endian_ptr = lib.ztensor_metadata_get_data_endianness_str(self._ptr)
+            if endian_ptr == ffi.NULL:
+                self._endianness = None
+            else:
+                self._endianness = ffi.string(endian_ptr).decode('utf-8')
+                lib.ztensor_free_string(endian_ptr)
+        return self._endianness
+
+    @property
+    def checksum(self):
+        """The checksum string if present, else None."""
+        if self._checksum == "not_checked":
+            checksum_ptr = lib.ztensor_metadata_get_checksum_str(self._ptr)
+            if checksum_ptr == ffi.NULL:
+                self._checksum = None
+            else:
+                self._checksum = ffi.string(checksum_ptr).decode('utf-8')
+                lib.ztensor_free_string(checksum_ptr)
+        return self._checksum
+
 
 class Reader:
     """A Pythonic context manager for reading zTensor files."""
@@ -120,17 +220,47 @@ class Reader:
         path_bytes = file_path.encode('utf-8')
         ptr = lib.ztensor_reader_open(path_bytes)
         _check_ptr(ptr, f"Reader open: {file_path}")
-        # The pointer is automatically garbage collected by CFFI.
         self._ptr = ffi.gc(ptr, lib.ztensor_reader_free)
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        # CFFI's garbage collector handles freeing the reader pointer automatically.
-        # No explicit free is needed here, simplifying the context manager.
         self._ptr = None
 
+    def __len__(self):
+        """Returns the number of tensors in the file."""
+        if self._ptr is None: raise ZTensorError("Reader is closed.")
+        return lib.ztensor_reader_get_metadata_count(self._ptr)
+
+    def __iter__(self):
+        """Iterates over the metadata of all tensors in the file."""
+        if self._ptr is None: raise ZTensorError("Reader is closed.")
+        for i in range(len(self)):
+            yield self[i]
+
+    def __getitem__(self, index: int) -> TensorMetadata:
+        """Retrieves metadata for a tensor by its index."""
+        if self._ptr is None: raise ZTensorError("Reader is closed.")
+        if index >= len(self):
+            raise IndexError("Tensor index out of range")
+        meta_ptr = lib.ztensor_reader_get_metadata_by_index(self._ptr, index)
+        _check_ptr(meta_ptr, f"get_metadata_by_index: {index}")
+        return TensorMetadata(meta_ptr)
+
+    def list_tensors(self) -> list[TensorMetadata]:
+        """Returns a list of all TensorMetadata objects in the file."""
+        return list(self)
+
+    def get_tensor_names(self) -> list[str]:
+        """Returns a list of all tensor names in the file."""
+        if self._ptr is None: raise ZTensorError("Reader is closed.")
+        c_array_ptr = lib.ztensor_reader_get_all_tensor_names(self._ptr)
+        _check_ptr(c_array_ptr, "get_all_tensor_names")
+        c_array_ptr = ffi.gc(c_array_ptr, lib.ztensor_free_string_array)
+
+        return [ffi.string(c_array_ptr.strings[i]).decode('utf-8') for i in range(c_array_ptr.len)]
+
     def get_metadata(self, name: str) -> TensorMetadata:
         """Retrieves metadata for a tensor by its name."""
         if self._ptr is None: raise ZTensorError("Reader is closed.")
@@ -139,32 +269,60 @@ class Reader:
         _check_ptr(meta_ptr, f"get_metadata: {name}")
         return TensorMetadata(meta_ptr)
 
-    def read_tensor(self, name: str) -> np.ndarray:
-        """Reads a tensor by name and returns it as a NumPy array (zero-copy)."""
-        metadata = self.get_metadata(name)
+    def read_tensor(self, name: str, to: str = 'numpy'):
+        """
+        Reads a tensor by name and returns it as a NumPy array or PyTorch tensor.
+        This is a zero-copy operation for both formats (for CPU tensors).
+
+        Args:
+            name (str): The name of the tensor to read.
+            to (str): The desired output format. Either 'numpy' (default) or 'torch'.
 
-        # This check is now more robust.
-        dtype = metadata.dtype
-        if dtype is None:
-            raise ZTensorError(f"Unsupported ztensor dtype: '{metadata.dtype_str}'")
+        Returns:
+            np.ndarray or torch.Tensor: The tensor data.
+        """
+        if self._ptr is None: raise ZTensorError("Reader is closed.")
+        if to not in ['numpy', 'torch']:
+            raise ValueError(f"Unsupported format: '{to}'. Choose 'numpy' or 'torch'.")
 
+        metadata = self.get_metadata(name)
         view_ptr = lib.ztensor_reader_read_tensor_view(self._ptr, metadata._ptr)
         _check_ptr(view_ptr, f"read_tensor: {name}")
 
         # Let CFFI manage the lifetime of the view pointer.
         view_ptr = ffi.gc(view_ptr, lib.ztensor_free_tensor_view)
 
-        # CORRECTED: Create array using the subclass, which handles reshaping and memory.
-        # With the correct bfloat16 dtype, np.frombuffer will now correctly interpret
-        # the buffer, creating an array with the right number of elements (2048).
-        array = _ZTensorView(
-            buffer=ffi.buffer(view_ptr.data, view_ptr.len),
-            dtype=dtype,
-            shape=metadata.shape,
-            view_ptr=view_ptr
-        )
+        if to == 'numpy':
+            # Use the custom _ZTensorView to safely manage the FFI pointer lifetime.
+            return _ZTensorView(
+                buffer=ffi.buffer(view_ptr.data, view_ptr.len),
+                dtype=metadata.dtype,  # This property raises on unsupported dtypes
+                shape=metadata.shape,
+                view_ptr=view_ptr
+            )
+
+        elif to == 'torch':
+            if not TORCH_AVAILABLE:
+                raise ZTensorError("PyTorch is not installed. Cannot return a torch tensor.")
 
-        return array
+            # Get the corresponding torch dtype, raising if not supported.
+            torch_dtype = DTYPE_ZT_TO_TORCH.get(metadata.dtype_str)
+            if torch_dtype is None:
+                raise ZTensorError(
+                    f"Cannot read tensor '{name}' as a PyTorch tensor. "
+                    f"The dtype '{metadata.dtype_str}' is not supported by PyTorch."
+                )
+
+            # Create a tensor directly from the buffer to avoid numpy conversion issues.
+            buffer = ffi.buffer(view_ptr.data, view_ptr.len)
+            torch_tensor = torch.frombuffer(buffer, dtype=torch_dtype).reshape(metadata.shape)
+
+            # CRITICAL: Attach the memory owner to the tensor to manage its lifetime.
+            # This ensures the Rust memory (held by view_ptr) is not freed while the
+            # torch tensor is still in use.
+            torch_tensor._owner = view_ptr
+
+            return torch_tensor
 
 
 class Writer:
@@ -174,8 +332,6 @@ class Writer:
         path_bytes = file_path.encode('utf-8')
         ptr = lib.ztensor_writer_create(path_bytes)
         _check_ptr(ptr, f"Writer create: {file_path}")
-        # The pointer is consumed by finalize, so we don't use ffi.gc here.
-        # The writer should be freed via finalize or ztensor_writer_free if finalize fails.
         self._ptr = ptr
         self._finalized = False
 
@@ -183,46 +339,68 @@ class Writer:
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        # Automatically finalize on exit if not already done and no error occurred.
         if self._ptr and not self._finalized:
             if exc_type is None:
                 self.finalize()
             else:
-                # If an error occurred, don't finalize, just free the writer to prevent leaks.
+                # If an error occurred, just free the handle without finalizing
                 lib.ztensor_writer_free(self._ptr)
                 self._ptr = None
 
-    def add_tensor(self, name: str, tensor: np.ndarray):
-        """Adds a NumPy array as a tensor to the file."""
-        if not self._ptr: raise ZTensorError("Writer is closed or finalized.")
+    def add_tensor(self, name: str, tensor):
+        """
+        Adds a NumPy or PyTorch tensor to the file (zero-copy).
+        Supports float16 and bfloat16 types.
 
-        name_bytes = name.encode('utf-8')
-        tensor = np.ascontiguousarray(tensor)  # Ensure data is contiguous.
+        Args:
+            name (str): The name of the tensor to add.
+            tensor (np.ndarray or torch.Tensor): The tensor data to write.
+        """
+        if not self._ptr: raise ZTensorError("Writer is closed or finalized.")
 
-        shape_array = np.array(tensor.shape, dtype=np.uint64)
-        shape_ptr = ffi.cast("uint64_t*", shape_array.ctypes.data)
+        # --- Polymorphic tensor handling ---
+        if isinstance(tensor, np.ndarray):
+            tensor = np.ascontiguousarray(tensor)
+            shape = tensor.shape
+            dtype_str = DTYPE_NP_TO_ZT.get(tensor.dtype)
+            data_ptr = ffi.cast("unsigned char*", tensor.ctypes.data)
+            nbytes = tensor.nbytes
+
+        elif TORCH_AVAILABLE and isinstance(tensor, torch.Tensor):
+            if tensor.is_cuda:
+                raise ZTensorError("Cannot write directly from a CUDA tensor. Copy to CPU first using .cpu().")
+            tensor = tensor.contiguous()
+            shape = tuple(tensor.shape)
+            dtype_str = DTYPE_TORCH_TO_ZT.get(tensor.dtype)
+            data_ptr = ffi.cast("unsigned char*", tensor.data_ptr())
+            nbytes = tensor.numel() * tensor.element_size()
+
+        else:
+            supported = "np.ndarray" + (" or torch.Tensor" if TORCH_AVAILABLE else "")
+            raise TypeError(f"Unsupported tensor type: {type(tensor)}. Must be {supported}.")
 
-        # The updated DTYPE_NP_TO_ZT will now correctly handle bfloat16 tensors.
-        dtype_str = DTYPE_NP_TO_ZT.get(tensor.dtype)
         if not dtype_str:
-            raise ZTensorError(f"Unsupported NumPy dtype: {tensor.dtype}")
-        dtype_bytes = dtype_str.encode('utf-8')
+            msg = f"Unsupported dtype: {tensor.dtype}."
+            if 'bfloat16' in str(tensor.dtype) and not ML_DTYPES_AVAILABLE:
+                msg += " For NumPy bfloat16 support, please install the 'ml_dtypes' package."
+            raise ZTensorError(msg)
 
-        # CORRECTED: Cast to `unsigned char*` to match the CFFI definition and Rust FFI.
-        data_ptr = ffi.cast("unsigned char*", tensor.ctypes.data)
+        name_bytes = name.encode('utf-8')
+        shape_array = np.array(shape, dtype=np.uint64)
+        shape_ptr = ffi.cast("uint64_t*", shape_array.ctypes.data)
+        dtype_bytes = dtype_str.encode('utf-8')
 
         status = lib.ztensor_writer_add_tensor(
-            self._ptr, name_bytes, shape_ptr, len(tensor.shape),
-            dtype_bytes, data_ptr, tensor.nbytes
+            self._ptr, name_bytes, shape_ptr, len(shape),
+            dtype_bytes, data_ptr, nbytes
         )
         _check_status(status, f"add_tensor: {name}")
 
     def finalize(self):
         """Finalizes the zTensor file, writing the metadata index."""
         if not self._ptr: raise ZTensorError("Writer is already closed or finalized.")
-
         status = lib.ztensor_writer_finalize(self._ptr)
-        self._ptr = None  # The writer pointer is consumed and invalidated by the Rust call.
+        self._ptr = None  # The writer is consumed in Rust
         self._finalized = True
         _check_status(status, "finalize")
 

ztensor/ztensor/ffi.py

@@ -3,8 +3,8 @@ import _cffi_backend
 
 ffi = _cffi_backend.FFI('ffi',
     _version = 0x2601,
-    _types = b'\x00\x00\x29\x0D\x00\x00\x3D\x03\x00\x00\x3C\x03\x00\x00\x00\x0F\x00\x00\x2C\x0D\x00\x00\x3D\x03\x00\x00\x3F\x03\x00\x00\x00\x0F\x00\x00\x01\x0D\x00\x00\x06\x11\x00\x00\x00\x0F\x00\x00\x14\x0D\x00\x00\x06\x11\x00\x00\x00\x0F\x00\x00\x35\x0D\x00\x00\x02\x11\x00\x00\x00\x0F\x00\x00\x06\x0D\x00\x00\x00\x0F\x00\x00\x40\x0D\x00\x00\x3E\x03\x00\x00\x00\x0F\x00\x00\x40\x0D\x00\x00\x14\x11\x00\x00\x06\x11\x00\x00\x41\x03\x00\x00\x1C\x01\x00\x00\x06\x11\x00\x00\x42\x03\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x1A\x0D\x00\x00\x02\x11\x00\x00\x00\x0F\x00\x00\x1A\x0D\x00\x00\x05\x11\x00\x00\x00\x0F\x00\x00\x38\x0D\x00\x00\x02\x11\x00\x00\x00\x0F\x00\x00\x44\x0D\x00\x00\x3B\x03\x00\x00\x00\x0F\x00\x00\x44\x0D\x00\x00\x3C\x03\x00\x00\x00\x0F\x00\x00\x44\x0D\x00\x00\x01\x11\x00\x00\x00\x0F\x00\x00\x44\x0D\x00\x00\x14\x11\x00\x00\x00\x0F\x00\x00\x44\x0D\x00\x00\x3F\x03\x00\x00\x00\x0F\x00\x00\x44\x0D\x00\x00\x41\x03\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x00\x09\x00\x00\x01\x09\x00\x00\x02\x09\x00\x00\x03\x09\x00\x00\x02\x01\x00\x00\x07\x01\x00\x00\x18\x01\x00\x00\x04\x01\x00\x00\x44\x03\x00\x00\x00\x01',
-    _globals = (b'\xFF\xFF\xFF\x1FALIGNMENT',64,b'\x00\x00\x34\x23ztensor_free_string',0,b'\x00\x00\x28\x23ztensor_free_tensor_view',0,b'\x00\x00\x37\x23ztensor_free_u64_array',0,b'\x00\x00\x11\x23ztensor_last_error_message',0,b'\x00\x00\x2B\x23ztensor_metadata_free',0,b'\x00\x00\x0E\x23ztensor_metadata_get_dtype_str',0,b'\x00\x00\x0E\x23ztensor_metadata_get_name',0,b'\x00\x00\x25\x23ztensor_metadata_get_shape_data',0,b'\x00\x00\x1F\x23ztensor_metadata_get_shape_len',0,b'\x00\x00\x2E\x23ztensor_reader_free',0,b'\x00\x00\x04\x23ztensor_reader_get_metadata_by_name',0,b'\x00\x00\x22\x23ztensor_reader_get_metadata_count',0,b'\x00\x00\x08\x23ztensor_reader_open',0,b'\x00\x00\x00\x23ztensor_reader_read_tensor_view',0,b'\x00\x00\x16\x23ztensor_writer_add_tensor',0,b'\x00\x00\x0B\x23ztensor_writer_create',0,b'\x00\x00\x13\x23ztensor_writer_finalize',0,b'\x00\x00\x31\x23ztensor_writer_free',0),
-    _struct_unions = ((b'\x00\x00\x00\x3B\x00\x00\x00\x02CTensorDataView',b'\x00\x00\x1C\x11data',b'\x00\x00\x1A\x11len',b'\x00\x00\x43\x11_owner'),(b'\x00\x00\x00\x3C\x00\x00\x00\x10TensorMetadata',),(b'\x00\x00\x00\x3D\x00\x00\x00\x10ZTensorReader_BufReader_File',),(b'\x00\x00\x00\x3E\x00\x00\x00\x10ZTensorWriter_BufWriter_File',)),
-    _typenames = (b'\x00\x00\x00\x3BCTensorDataView',b'\x00\x00\x00\x3CCTensorMetadata',b'\x00\x00\x00\x3DCZTensorReader',b'\x00\x00\x00\x3ECZTensorWriter',b'\x00\x00\x00\x3CTensorMetadata',b'\x00\x00\x00\x3DZTensorReader_BufReader_File',b'\x00\x00\x00\x3EZTensorWriter_BufWriter_File'),
+    _types = b'\x00\x00\x33\x0D\x00\x00\x4B\x03\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x4B\x03\x00\x00\x4A\x03\x00\x00\x00\x0F\x00\x00\x39\x0D\x00\x00\x01\x11\x00\x00\x4E\x03\x00\x00\x00\x0F\x00\x00\x39\x0D\x00\x00\x01\x11\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x04\x0D\x00\x00\x09\x11\x00\x00\x00\x0F\x00\x00\x1B\x0D\x00\x00\x09\x11\x00\x00\x00\x0F\x00\x00\x42\x0D\x00\x00\x05\x11\x00\x00\x00\x0F\x00\x00\x09\x0D\x00\x00\x00\x0F\x00\x00\x4F\x0D\x00\x00\x4C\x03\x00\x00\x00\x0F\x00\x00\x4F\x0D\x00\x00\x1B\x11\x00\x00\x09\x11\x00\x00\x50\x03\x00\x00\x1C\x01\x00\x00\x09\x11\x00\x00\x51\x03\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x0D\x0D\x00\x00\x05\x11\x00\x00\x00\x0F\x00\x00\x0D\x0D\x00\x00\x01\x11\x00\x00\x00\x0F\x00\x00\x45\x0D\x00\x00\x05\x11\x00\x00\x00\x0F\x00\x00\x50\x0D\x00\x00\x05\x11\x00\x00\x00\x0F\x00\x00\x53\x0D\x00\x00\x48\x03\x00\x00\x00\x0F\x00\x00\x53\x0D\x00\x00\x49\x03\x00\x00\x00\x0F\x00\x00\x53\x0D\x00\x00\x4A\x03\x00\x00\x00\x0F\x00\x00\x53\x0D\x00\x00\x04\x11\x00\x00\x00\x0F\x00\x00\x53\x0D\x00\x00\x1B\x11\x00\x00\x00\x0F\x00\x00\x53\x0D\x00\x00\x4E\x03\x00\x00\x00\x0F\x00\x00\x53\x0D\x00\x00\x50\x03\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x00\x09\x00\x00\x01\x09\x00\x00\x02\x09\x00\x00\x03\x09\x00\x00\x04\x09\x00\x00\x42\x03\x00\x00\x02\x01\x00\x00\x07\x01\x00\x00\x18\x01\x00\x00\x04\x01\x00\x00\x53\x03\x00\x00\x00\x01',
+    _globals = (b'\xFF\xFF\xFF\x1FALIGNMENT',64,b'\x00\x00\x41\x23ztensor_free_string',0,b'\x00\x00\x32\x23ztensor_free_string_array',0,b'\x00\x00\x35\x23ztensor_free_tensor_view',0,b'\x00\x00\x44\x23ztensor_free_u64_array',0,b'\x00\x00\x18\x23ztensor_last_error_message',0,b'\x00\x00\x38\x23ztensor_metadata_free',0,b'\x00\x00\x15\x23ztensor_metadata_get_checksum_str',0,b'\x00\x00\x15\x23ztensor_metadata_get_data_endianness_str',0,b'\x00\x00\x15\x23ztensor_metadata_get_dtype_str',0,b'\x00\x00\x15\x23ztensor_metadata_get_encoding_str',0,b'\x00\x00\x15\x23ztensor_metadata_get_layout_str',0,b'\x00\x00\x15\x23ztensor_metadata_get_name',0,b'\x00\x00\x2F\x23ztensor_metadata_get_offset',0,b'\x00\x00\x2C\x23ztensor_metadata_get_shape_data',0,b'\x00\x00\x26\x23ztensor_metadata_get_shape_len',0,b'\x00\x00\x2F\x23ztensor_metadata_get_size',0,b'\x00\x00\x3B\x23ztensor_reader_free',0,b'\x00\x00\x00\x23ztensor_reader_get_all_tensor_names',0,b'\x00\x00\x0B\x23ztensor_reader_get_metadata_by_index',0,b'\x00\x00\x07\x23ztensor_reader_get_metadata_by_name',0,b'\x00\x00\x29\x23ztensor_reader_get_metadata_count',0,b'\x00\x00\x0F\x23ztensor_reader_open',0,b'\x00\x00\x03\x23ztensor_reader_read_tensor_view',0,b'\x00\x00\x1D\x23ztensor_writer_add_tensor',0,b'\x00\x00\x12\x23ztensor_writer_create',0,b'\x00\x00\x1A\x23ztensor_writer_finalize',0,b'\x00\x00\x3E\x23ztensor_writer_free',0),
+    _struct_unions = ((b'\x00\x00\x00\x48\x00\x00\x00\x02CStringArray',b'\x00\x00\x4D\x11strings',b'\x00\x00\x0D\x11len'),(b'\x00\x00\x00\x49\x00\x00\x00\x02CTensorDataView',b'\x00\x00\x23\x11data',b'\x00\x00\x0D\x11len',b'\x00\x00\x52\x11_owner'),(b'\x00\x00\x00\x4A\x00\x00\x00\x10TensorMetadata',),(b'\x00\x00\x00\x4B\x00\x00\x00\x10ZTensorReader_BufReader_File',),(b'\x00\x00\x00\x4C\x00\x00\x00\x10ZTensorWriter_BufWriter_File',)),
+    _typenames = (b'\x00\x00\x00\x48CStringArray',b'\x00\x00\x00\x49CTensorDataView',b'\x00\x00\x00\x4ACTensorMetadata',b'\x00\x00\x00\x4BCZTensorReader',b'\x00\x00\x00\x4CCZTensorWriter',b'\x00\x00\x00\x4ATensorMetadata',b'\x00\x00\x00\x4BZTensorReader_BufReader_File',b'\x00\x00\x00\x4CZTensorWriter_BufWriter_File'),
 )

{ztensor-0.1.1.dist-info → ztensor-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ztensor
-Version: 0.1.1
+Version: 0.1.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

ztensor-0.1.4.dist-info/RECORD

@@ -0,0 +1,9 @@
+ztensor-0.1.4.dist-info/METADATA,sha256=ECD-zbYFWEiDg5HYTbi2hthPYh1xKG9y5tBd2VZPSX8,4446
+ztensor-0.1.4.dist-info/WHEEL,sha256=iTWsRz1hnXDQdoNmAgkYGjvp2bRaBb4-srKwYiDluzw,104
+ztensor-0.1.4.dist-info/licenses/LICENSE,sha256=AoeyV1LzTyOz9sbr6uOzk_P0lW963DvhJHnVNVQlI3Y,1063
+ztensor.libs/libgcc_s-5b5488a6.so.1,sha256=HGKUsVmTeNAxEdSy7Ua5Vh_I9FN3RCbPWzvZ7H_TrwE,2749061
+ztensor/__init__.py,sha256=8n2-jVn_Pi95MmfuZeo5K0FKOQwWQLa1hHXM5kBPs2c,15794
+ztensor/ztensor/__init__.py,sha256=sIpB0pJYFX20TdZapIoPMxqMz37wKJyxCkAlTemWDq4,140
+ztensor/ztensor/ffi.py,sha256=xK_OkOYQEMtfTRag-zlNCSLLj2JHB14qMc1cbtqTOB8,3601
+ztensor/ztensor/libztensor.so,sha256=v03q1TASiuFenBWXRXrTQyhh2-UvTVu6thQwQuSFiKg,1636121
+ztensor-0.1.4.dist-info/RECORD,,

{ztensor-0.1.1.dist-info → ztensor-0.1.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.9.0)
+Generator: maturin (1.9.1)
 Root-Is-Purelib: false
 Tag: py3-none-musllinux_1_2_armv7l

ztensor-0.1.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-ztensor-0.1.1.dist-info/METADATA,sha256=dpaZnxqi7u30Z3uH641XoVg_DeH5k25UamSBjzseBos,4446
-ztensor-0.1.1.dist-info/WHEEL,sha256=uk6lXffjnM20NjdJS1j5pULyv9smQtZKAlwiwmTYIRE,104
-ztensor-0.1.1.dist-info/licenses/LICENSE,sha256=AoeyV1LzTyOz9sbr6uOzk_P0lW963DvhJHnVNVQlI3Y,1063
-ztensor.libs/libgcc_s-5b5488a6.so.1,sha256=HGKUsVmTeNAxEdSy7Ua5Vh_I9FN3RCbPWzvZ7H_TrwE,2749061
-ztensor/__init__.py,sha256=pzpS0XNcpBb762OPUG7-3raEJxz7P99KX6CGAdh-DS0,9086
-ztensor/ztensor/__init__.py,sha256=sIpB0pJYFX20TdZapIoPMxqMz37wKJyxCkAlTemWDq4,140
-ztensor/ztensor/ffi.py,sha256=J7CG26lx0Xu0IjYR7GWev-BDgGQXseKA4cjkh0IhnLE,2746
-ztensor/ztensor/libztensor.so,sha256=9bgmcP7Tj8o3loKKYgTfK6kzL1wcgxoKCTykU6CSvEI,1611249
-ztensor-0.1.1.dist-info/RECORD,,