ztensor 0.1.2__tar.gz → 0.1.4__tar.gz

{ztensor-0.1.2 → ztensor-0.1.4}/PKG-INFO

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

{ztensor-0.1.2 → ztensor-0.1.4}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "maturin"
 [project]
 # The name of your package on PyPI.
 name = "ztensor"
-version = "0.1.2"
+version = "0.1.4"
 description = "Python bindings for the zTensor library."
 readme = "README.md" # It's good practice to have a README.
 authors = [

ztensor-0.1.4/python/examples/test.py

@@ -0,0 +1,171 @@
+import unittest
+import os
+import shutil
+import tempfile
+import numpy as np
+
+# --- Conditional PyTorch Import ---
+try:
+    import torch
+
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+
+# --- Import the ztensor wrapper ---
+# Assuming the bindings file is named 'bindings.py' in a 'ztensor' package/directory
+from ztensor import Reader, Writer, ZTensorError, TensorMetadata
+
+
+class TestZTensorBindings(unittest.TestCase):
+
+    def setUp(self):
+        """Set up a temporary directory for test files."""
+        self.test_dir = tempfile.mkdtemp()
+        self.test_file = os.path.join(self.test_dir, "test.zt")
+
+    def tearDown(self):
+        """Remove the temporary directory and its contents."""
+        shutil.rmtree(self.test_dir)
+
+    def test_01_writer_and_reader_numpy(self):
+        """Test writing and reading a single NumPy tensor."""
+        tensor_a = np.arange(24, dtype=np.float32).reshape(2, 3, 4)
+        tensor_b = np.array([[True, False], [False, True]], dtype=bool)
+
+        with Writer(self.test_file) as writer:
+            writer.add_tensor("tensor_a", tensor_a)
+            writer.add_tensor("tensor_b", tensor_b)
+
+        self.assertTrue(os.path.exists(self.test_file))
+
+        with Reader(self.test_file) as reader:
+            read_a = reader.read_tensor("tensor_a")
+            read_b = reader.read_tensor("tensor_b")
+
+            self.assertIsInstance(read_a, np.ndarray)
+            self.assertTrue(np.array_equal(tensor_a, read_a))
+            self.assertEqual(tensor_a.dtype, read_a.dtype)
+            self.assertEqual(tensor_a.shape, read_a.shape)
+
+            self.assertIsInstance(read_b, np.ndarray)
+            self.assertTrue(np.array_equal(tensor_b, read_b))
+
+    @unittest.skipIf(not TORCH_AVAILABLE, "PyTorch not installed")
+    def test_02_writer_and_reader_torch(self):
+        """Test writing and reading a PyTorch tensor."""
+        tensor_a = torch.randn(10, 20, dtype=torch.float16)
+        tensor_b = torch.randint(0, 255, (100,), dtype=torch.uint8)
+
+        with Writer(self.test_file) as writer:
+            writer.add_tensor("torch_a", tensor_a)
+            writer.add_tensor("torch_b", tensor_b)
+
+        with Reader(self.test_file) as reader:
+            # Read back as torch tensor
+            read_a_torch = reader.read_tensor("torch_a", to='torch')
+            self.assertIsInstance(read_a_torch, torch.Tensor)
+            self.assertTrue(torch.equal(tensor_a, read_a_torch))
+            self.assertEqual(tensor_a.dtype, read_a_torch.dtype)
+
+            # Read back as numpy array
+            read_b_np = reader.read_tensor("torch_b", to='numpy')
+            self.assertIsInstance(read_b_np, np.ndarray)
+            self.assertTrue(np.array_equal(tensor_b.numpy(), read_b_np))
+
+    def test_03_metadata_access_and_iteration(self):
+        """Test the reader's container and metadata features."""
+        tensors = {
+            "tensor_int": np.ones((5, 5), dtype=np.int32),
+            "tensor_float": np.zeros((10,), dtype=np.float64),
+            "scalar": np.array(3.14, dtype=np.float32)
+        }
+        tensor_names = sorted(tensors.keys())
+
+        with Writer(self.test_file) as writer:
+            for name, tensor in tensors.items():
+                writer.add_tensor(name, tensor)
+
+        with Reader(self.test_file) as reader:
+            # Test __len__
+            self.assertEqual(len(reader), 3)
+
+            # Test get_tensor_names
+            read_names = sorted(reader.get_tensor_names())
+            self.assertEqual(tensor_names, read_names)
+
+            # Test __iter__ and __getitem__
+            all_meta = []
+            for i in range(len(reader)):
+                meta = reader[i]
+                self.assertIsInstance(meta, TensorMetadata)
+                all_meta.append(meta.name)
+            self.assertEqual(tensor_names, sorted(all_meta))
+
+            # Test list_tensors
+            self.assertEqual(len(reader.list_tensors()), 3)
+
+            # Test specific metadata properties
+            meta_scalar = reader.get_metadata("scalar")
+            self.assertEqual(meta_scalar.name, "scalar")
+            self.assertEqual(meta_scalar.shape, (1, ))
+            self.assertEqual(meta_scalar.dtype, np.dtype('float32'))
+            self.assertEqual(meta_scalar.dtype_str, 'float32')
+            self.assertGreater(meta_scalar.offset, 0)
+            self.assertGreater(meta_scalar.size, 0)
+            self.assertEqual(meta_scalar.layout, "dense")
+            self.assertEqual(meta_scalar.encoding, "raw")
+            self.assertIn(meta_scalar.endianness, ["little", "big"])
+            self.assertIsNone(meta_scalar.checksum)
+
+    def test_04_error_handling(self):
+        """Test expected failure modes."""
+        tensor = np.arange(10)
+        with Writer(self.test_file) as writer:
+            writer.add_tensor("my_tensor", tensor)
+
+        # Test reading non-existent tensor
+        with Reader(self.test_file) as reader:
+            with self.assertRaisesRegex(ZTensorError, "Tensor not found"):
+                reader.read_tensor("non_existent_tensor")
+
+        # Test accessing closed reader
+        reader = Reader(self.test_file)
+        reader.__exit__(None, None, None)  # Manually close
+        with self.assertRaisesRegex(ZTensorError, "Reader is closed"):
+            len(reader)
+        with self.assertRaisesRegex(ZTensorError, "Reader is closed"):
+            reader.read_tensor("my_tensor")
+
+        # Test index out of range
+        with Reader(self.test_file) as reader:
+            with self.assertRaises(IndexError):
+                reader[99]
+
+        # Test writing to a finalized writer
+        writer = Writer(self.test_file)
+        writer.add_tensor("t1", tensor)
+        writer.finalize()
+        with self.assertRaisesRegex(ZTensorError, "Writer is closed or finalized."):
+            writer.add_tensor("t2", tensor)
+
+    def test_05_writer_context_manager_exception(self):
+        """Ensure writer does not finalize on error inside `with` block."""
+        bad_file_path = os.path.join(self.test_dir, "bad_file.zt")
+        try:
+            with Writer(bad_file_path) as writer:
+                writer.add_tensor("good_tensor", np.arange(5))
+                raise ValueError("Simulating an error during writing")
+        except ValueError:
+            pass  # Expected
+
+        # The file should exist but be empty/invalid because finalize was not called.
+        self.assertTrue(os.path.exists(bad_file_path))
+        # Attempting to read should fail
+        with self.assertRaises(ZTensorError):
+            with Reader(bad_file_path) as reader:
+                len(reader)
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

{ztensor-0.1.2 → ztensor-0.1.4}/python/ztensor/__init__.py

@@ -92,12 +92,23 @@ class TensorMetadata:
     def __init__(self, meta_ptr):
         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")
@@ -107,6 +118,7 @@ class TensorMetadata:
 
     @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")
@@ -116,7 +128,7 @@ class TensorMetadata:
 
     @property
     def dtype(self):
-        """Returns the numpy dtype for this tensor."""
+        """The numpy dtype for this tensor."""
         dtype_str = self.dtype_str
         dt = DTYPE_ZT_TO_NP.get(dtype_str)
         if dt is None:
@@ -130,6 +142,7 @@ class TensorMetadata:
 
     @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:
@@ -141,6 +154,64 @@ class TensorMetadata:
                 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."""
@@ -157,6 +228,39 @@ class Reader:
     def __exit__(self, exc_type, exc_val, exc_tb):
         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.")
@@ -177,6 +281,7 @@ class Reader:
         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'.")
 
@@ -238,6 +343,7 @@ class Writer:
             if exc_type is None:
                 self.finalize()
             else:
+                # If an error occurred, just free the handle without finalizing
                 lib.ztensor_writer_free(self._ptr)
                 self._ptr = None
 
@@ -294,7 +400,7 @@ class Writer:
         """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
+        self._ptr = None  # The writer is consumed in Rust
         self._finalized = True
         _check_status(status, "finalize")
 

{ztensor-0.1.2 → ztensor-0.1.4}/src/ffi.rs

@@ -12,7 +12,35 @@ use crate::models::{ChecksumAlgorithm, DType, DataEndianness, Encoding, Layout,
 use crate::reader::ZTensorReader;
 use crate::writer::ZTensorWriter;
 
+// --- C-Compatible Structs & Handles ---
+
+/// Opaque handle to a file-based zTensor reader.
+pub type CZTensorReader = ZTensorReader<BufReader<std::fs::File>>;
+/// Opaque handle to a file-based zTensor writer.
+pub type CZTensorWriter = ZTensorWriter<BufWriter<std::fs::File>>;
+/// Opaque handle to an in-memory zTensor writer.
+pub type CInMemoryZTensorWriter = ZTensorWriter<Cursor<Vec<u8>>>;
+/// Opaque, owned handle to a tensor's metadata.
+pub type CTensorMetadata = TensorMetadata;
+
+/// A self-contained, C-compatible view of owned tensor data.
+#[repr(C)]
+pub struct CTensorDataView {
+    pub data: *const c_uchar,
+    pub len: size_t,
+    // Private field holding the owned Vec<u8> data.
+    _owner: *mut c_void,
+}
+
+/// A C-compatible, heap-allocated array of C strings.
+#[repr(C)]
+pub struct CStringArray {
+    pub strings: *mut *mut c_char,
+    pub len: size_t,
+}
+
 // --- Error Handling ---
+
 lazy_static! {
     static ref LAST_ERROR: Mutex<Option<CString>> = Mutex::new(None);
 }
@@ -23,6 +51,10 @@ fn update_last_error(err: ZTensorError) {
     *LAST_ERROR.lock().unwrap() = Some(msg);
 }
 
+/// Retrieves the last error message set by a failed API call.
+///
+/// The returned string is valid until the next API call.
+/// Returns `null` if no error has occurred.
 #[unsafe(no_mangle)]
 pub extern "C" fn ztensor_last_error_message() -> *const c_char {
     match LAST_ERROR.lock().unwrap().as_ref() {
@@ -31,30 +63,51 @@ pub extern "C" fn ztensor_last_error_message() -> *const c_char {
     }
 }
 
-// --- Opaque Structs and Handles ---
-
-// Reader is now generic over R: Read + Seek.
-// For the C API, we'll expose a version that works with files.
-pub type CZTensorReader = ZTensorReader<BufReader<std::fs::File>>;
-
-// Writer is also generic. We'll expose a file-based and in-memory version.
-pub type CZTensorWriter = ZTensorWriter<BufWriter<std::fs::File>>;
-pub type CInMemoryZTensorWriter = ZTensorWriter<Cursor<Vec<u8>>>;
+// --- Internal Helpers ---
 
-// Represents an owned, C-compatible TensorMetadata.
-pub type CTensorMetadata = TensorMetadata;
+/// A macro to safely access the Rust object behind an opaque C pointer.
+/// It checks for null and returns a safe reference, handling the error case.
+macro_rules! ztensor_handle {
+    ($ptr:expr) => {
+        if $ptr.is_null() {
+            update_last_error(ZTensorError::Other("Null pointer passed as handle".into()));
+            return ptr::null_mut();
+        } else {
+            unsafe { &*$ptr }
+        }
+    };
+    (mut $ptr:expr) => {
+        if $ptr.is_null() {
+            update_last_error(ZTensorError::Other("Null pointer passed as handle".into()));
+            return ptr::null_mut();
+        } else {
+            unsafe { &mut *$ptr }
+        }
+    };
+    ($ptr:expr, $err_ret:expr) => {
+        if $ptr.is_null() {
+            update_last_error(ZTensorError::Other("Null pointer passed as handle".into()));
+            return $err_ret;
+        } else {
+            unsafe { &*$ptr }
+        }
+    };
+    (mut $ptr:expr, $err_ret:expr) => {
+        if $ptr.is_null() {
+            update_last_error(ZTensorError::Other("Null pointer passed as handle".into()));
+            return $err_ret;
+        } else {
+            unsafe { &mut *$ptr }
+        }
+    };
+}
 
-// Represents a non-owning, zero-copy view of tensor data.
-#[repr(C)]
-pub struct CTensorDataView {
-    pub data: *const c_uchar,
-    pub len: size_t,
-    // Private field to hold the owned data, making this struct self-contained.
-    // The C side only sees a pointer to the data, but this struct owns the Vec.
-    _owner: *mut c_void,
+/// Helper to convert a Rust String into a C-style, null-terminated string pointer.
+fn to_cstring(s: String) -> *mut c_char {
+    CString::new(s).map_or(ptr::null_mut(), |cs| cs.into_raw())
 }
 
-// --- Reader Functions ---
+// --- Reader API ---
 
 #[unsafe(no_mangle)]
 pub extern "C" fn ztensor_reader_open(path_str: *const c_char) -> *mut CZTensorReader {
@@ -62,11 +115,8 @@ pub extern "C" fn ztensor_reader_open(path_str: *const c_char) -> *mut CZTensorR
         update_last_error(ZTensorError::Other("Null path provided".into()));
         return ptr::null_mut();
     }
-    let path = unsafe { CStr::from_ptr(path_str) };
-    let path_res = path.to_str().map(Path::new);
-
-    let path = match path_res {
-        Ok(p) => p,
+    let path = match unsafe { CStr::from_ptr(path_str).to_str() } {
+        Ok(s) => Path::new(s),
         Err(_) => {
             update_last_error(ZTensorError::Other("Invalid UTF-8 path".into()));
             return ptr::null_mut();
@@ -82,22 +132,9 @@ pub extern "C" fn ztensor_reader_open(path_str: *const c_char) -> *mut CZTensorR
     }
 }
 
-#[unsafe(no_mangle)]
-pub extern "C" fn ztensor_reader_free(reader_ptr: *mut CZTensorReader) {
-    if !reader_ptr.is_null() {
-        unsafe {
-            let _ = Box::from_raw(reader_ptr);
-        };
-    }
-}
-
 #[unsafe(no_mangle)]
 pub extern "C" fn ztensor_reader_get_metadata_count(reader_ptr: *const CZTensorReader) -> size_t {
-    let reader = unsafe {
-        reader_ptr
-            .as_ref()
-            .expect("Null pointer passed to ztensor_reader_get_metadata_count")
-    };
+    let reader = ztensor_handle!(reader_ptr, 0);
     reader.list_tensors().len()
 }
 
@@ -106,11 +143,7 @@ pub extern "C" fn ztensor_reader_get_metadata_by_name(
     reader_ptr: *const CZTensorReader,
     name_str: *const c_char,
 ) -> *mut CTensorMetadata {
-    let reader = unsafe {
-        reader_ptr
-            .as_ref()
-            .expect("Null pointer passed to ztensor_reader_get_metadata_by_name")
-    };
+    let reader = ztensor_handle!(reader_ptr);
     if name_str.is_null() {
         update_last_error(ZTensorError::Other("Null name pointer provided".into()));
         return ptr::null_mut();
@@ -126,24 +159,53 @@ pub extern "C" fn ztensor_reader_get_metadata_by_name(
     }
 }
 
-// --- Zero-Copy Tensor Data Reading ---
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_reader_get_metadata_by_index(
+    reader_ptr: *const CZTensorReader,
+    index: size_t,
+) -> *mut CTensorMetadata {
+    let reader = ztensor_handle!(reader_ptr);
+    match reader.list_tensors().get(index) {
+        Some(metadata) => Box::into_raw(Box::new(metadata.clone())),
+        None => {
+            update_last_error(ZTensorError::Other(format!(
+                "Index {} is out of bounds for tensor list of length {}",
+                index,
+                reader.list_tensors().len()
+            )));
+            ptr::null_mut()
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_reader_get_all_tensor_names(
+    reader_ptr: *const CZTensorReader,
+) -> *mut CStringArray {
+    let reader = ztensor_handle!(reader_ptr);
+    let names: Vec<CString> = reader
+        .list_tensors()
+        .iter()
+        .map(|m| CString::new(m.name.as_str()).unwrap())
+        .collect();
+
+    let mut c_names: Vec<*mut c_char> = names.into_iter().map(|s| s.into_raw()).collect();
+    let string_array = Box::new(CStringArray {
+        strings: c_names.as_mut_ptr(),
+        len: c_names.len(),
+    });
+
+    std::mem::forget(c_names); // C side is now responsible for this memory
+    Box::into_raw(string_array)
+}
 
-/// Reads tensor data into a view without copying. The view must be freed.
 #[unsafe(no_mangle)]
 pub extern "C" fn ztensor_reader_read_tensor_view(
     reader_ptr: *mut CZTensorReader,
     metadata_ptr: *const CTensorMetadata,
 ) -> *mut CTensorDataView {
-    let reader = unsafe {
-        reader_ptr
-            .as_mut()
-            .expect("Null reader pointer to read_tensor_view")
-    };
-    let metadata = unsafe {
-        metadata_ptr
-            .as_ref()
-            .expect("Null metadata pointer to read_tensor_view")
-    };
+    let reader = ztensor_handle!(mut reader_ptr);
+    let metadata = ztensor_handle!(metadata_ptr);
 
     match reader.read_raw_tensor_data(metadata) {
         Ok(data_vec) => {
@@ -161,84 +223,7 @@ pub extern "C" fn ztensor_reader_read_tensor_view(
     }
 }
 
-/// Frees the tensor data view.
-#[unsafe(no_mangle)]
-pub extern "C" fn ztensor_free_tensor_view(view_ptr: *mut CTensorDataView) {
-    if !view_ptr.is_null() {
-        unsafe {
-            let view = Box::from_raw(view_ptr);
-            // This will drop the Vec<u8> that `_owner` points to
-            let _ = Box::from_raw(view._owner as *mut Vec<u8>);
-        }
-    }
-}
-
-// --- Metadata Accessors ---
-// (These are largely the same but ensured to be safe)
-
-#[unsafe(no_mangle)]
-pub extern "C" fn ztensor_metadata_free(metadata_ptr: *mut CTensorMetadata) {
-    if !metadata_ptr.is_null() {
-        unsafe {
-            let _ = Box::from_raw(metadata_ptr);
-        };
-    }
-}
-
-fn to_cstring(s: String) -> *mut c_char {
-    CString::new(s).map_or(ptr::null_mut(), |cs| cs.into_raw())
-}
-
-#[unsafe(no_mangle)]
-pub extern "C" fn ztensor_metadata_get_name(metadata_ptr: *const CTensorMetadata) -> *mut c_char {
-    let metadata = unsafe { metadata_ptr.as_ref().expect("Null metadata pointer") };
-    to_cstring(metadata.name.clone())
-}
-
-#[unsafe(no_mangle)]
-pub extern "C" fn ztensor_metadata_get_dtype_str(
-    metadata_ptr: *const CTensorMetadata,
-) -> *mut c_char {
-    let metadata = unsafe { metadata_ptr.as_ref().expect("Null metadata pointer") };
-    to_cstring(metadata.dtype.to_string_key())
-}
-
-// ... other metadata accessors like get_offset, get_size, etc.
-
-/// Returns the number of dimensions in the tensor's shape.
-#[unsafe(no_mangle)]
-pub extern "C" fn ztensor_metadata_get_shape_len(metadata_ptr: *const CTensorMetadata) -> size_t {
-    let metadata = unsafe { metadata_ptr.as_ref().expect("Null metadata pointer") };
-    metadata.shape.len()
-}
-
-/// Returns a pointer to the shape data (an array of u64).
-/// The caller owns this memory and must free it with `ztensor_free_u64_array`.
-#[unsafe(no_mangle)]
-pub extern "C" fn ztensor_metadata_get_shape_data(
-    metadata_ptr: *const CTensorMetadata,
-) -> *mut u64 {
-    let metadata = unsafe { metadata_ptr.as_ref().expect("Null metadata pointer") };
-    // Clone the shape into a new Vec, get its raw pointer, and forget it
-    // so Rust doesn't deallocate it. The C side is now responsible.
-    let mut shape_vec = metadata.shape.clone();
-    let ptr = shape_vec.as_mut_ptr();
-    std::mem::forget(shape_vec);
-    ptr
-}
-
-/// Frees the shape array allocated by `ztensor_metadata_get_shape_data`.
-#[unsafe(no_mangle)]
-pub extern "C" fn ztensor_free_u64_array(ptr: *mut u64, len: size_t) {
-    if !ptr.is_null() {
-        unsafe {
-            // Reconstitute the Vec from the raw parts and let it drop, freeing the memory.
-            let _ = Vec::from_raw_parts(ptr, len, len);
-        }
-    }
-}
-
-// --- Writer Functions ---
+// --- Writer API ---
 
 #[unsafe(no_mangle)]
 pub extern "C" fn ztensor_writer_create(path_str: *const c_char) -> *mut CZTensorWriter {
@@ -246,9 +231,8 @@ pub extern "C" fn ztensor_writer_create(path_str: *const c_char) -> *mut CZTenso
         update_last_error(ZTensorError::Other("Null path provided".into()));
         return ptr::null_mut();
     }
-    let path = unsafe { CStr::from_ptr(path_str) };
-    let path = match path.to_str().map(Path::new) {
-        Ok(p) => p,
+    let path = match unsafe { CStr::from_ptr(path_str).to_str() } {
+        Ok(s) => Path::new(s),
         Err(_) => {
             update_last_error(ZTensorError::Other("Invalid UTF-8 path".into()));
             return ptr::null_mut();
@@ -264,14 +248,6 @@ pub extern "C" fn ztensor_writer_create(path_str: *const c_char) -> *mut CZTenso
     }
 }
 
-#[unsafe(no_mangle)]
-pub extern "C" fn ztensor_writer_free(writer_ptr: *mut CZTensorWriter) {
-    if !writer_ptr.is_null() {
-        let _ = unsafe { Box::from_raw(writer_ptr) };
-        // Dropping the writer will close the file.
-    }
-}
-
 #[unsafe(no_mangle)]
 pub extern "C" fn ztensor_writer_add_tensor(
     writer_ptr: *mut CZTensorWriter,
@@ -282,16 +258,26 @@ pub extern "C" fn ztensor_writer_add_tensor(
     data_ptr: *const c_uchar,
     data_len: size_t,
 ) -> c_int {
-    let writer = unsafe { writer_ptr.as_mut().expect("Null writer pointer") };
+    let writer = ztensor_handle!(mut writer_ptr, -1);
     let name = unsafe { CStr::from_ptr(name_str).to_str().unwrap() };
     let shape = unsafe { slice::from_raw_parts(shape_ptr, shape_len) };
     let dtype_str = unsafe { CStr::from_ptr(dtype_str).to_str().unwrap() };
     let data = unsafe { slice::from_raw_parts(data_ptr, data_len) };
 
     let dtype = match dtype_str {
+        "float64" => DType::Float64,
         "float32" => DType::Float32,
+        "float16" => DType::Float16,
+        "bfloat16" => DType::BFloat16,
+        "int64" => DType::Int64,
+        "int32" => DType::Int32,
+        "int16" => DType::Int16,
+        "int8" => DType::Int8,
+        "uint64" => DType::Uint64,
+        "uint32" => DType::Uint32,
+        "uint16" => DType::Uint16,
         "uint8" => DType::Uint8,
-        // ... add other dtypes
+        "bool" => DType::Bool,
         _ => {
             update_last_error(ZTensorError::UnsupportedDType(dtype_str.to_string()));
             return -1;
@@ -305,7 +291,7 @@ pub extern "C" fn ztensor_writer_add_tensor(
         Layout::Dense,
         Encoding::Raw,
         data.to_vec(),
-        Some(DataEndianness::Little), // Defaulting to little, could be a parameter
+        Some(DataEndianness::Little),
         ChecksumAlgorithm::None,
         None,
     );
@@ -324,8 +310,6 @@ pub extern "C" fn ztensor_writer_finalize(writer_ptr: *mut CZTensorWriter) -> c_
     if writer_ptr.is_null() {
         return -1;
     }
-    // `from_raw` takes ownership and will drop the writer when it goes out of scope.
-    // The writer's `drop` implementation should handle finalization.
     let writer = unsafe { Box::from_raw(writer_ptr) };
     match writer.finalize() {
         Ok(_) => 0,
@@ -336,13 +320,147 @@ pub extern "C" fn ztensor_writer_finalize(writer_ptr: *mut CZTensorWriter) -> c_
     }
 }
 
-// --- Memory Freeing for C ---
+// --- Metadata API ---
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_get_name(metadata_ptr: *const CTensorMetadata) -> *mut c_char {
+    let metadata = ztensor_handle!(metadata_ptr);
+    to_cstring(metadata.name.clone())
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_get_dtype_str(
+    metadata_ptr: *const CTensorMetadata,
+) -> *mut c_char {
+    let metadata = ztensor_handle!(metadata_ptr);
+    to_cstring(metadata.dtype.to_string_key())
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_get_offset(metadata_ptr: *const CTensorMetadata) -> u64 {
+    let metadata = ztensor_handle!(metadata_ptr, 0);
+    metadata.offset
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_get_size(metadata_ptr: *const CTensorMetadata) -> u64 {
+    let metadata = ztensor_handle!(metadata_ptr, 0);
+    metadata.size
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_get_layout_str(
+    metadata_ptr: *const CTensorMetadata,
+) -> *mut c_char {
+    let metadata = ztensor_handle!(metadata_ptr);
+    to_cstring(format!("{:?}", metadata.layout).to_lowercase())
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_get_encoding_str(
+    metadata_ptr: *const CTensorMetadata,
+) -> *mut c_char {
+    let metadata = ztensor_handle!(metadata_ptr);
+    to_cstring(format!("{:?}", metadata.encoding).to_lowercase())
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_get_data_endianness_str(
+    metadata_ptr: *const CTensorMetadata,
+) -> *mut c_char {
+    let metadata = ztensor_handle!(metadata_ptr);
+    match &metadata.data_endianness {
+        Some(endianness) => to_cstring(format!("{:?}", endianness).to_lowercase()),
+        None => ptr::null_mut(),
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_get_checksum_str(
+    metadata_ptr: *const CTensorMetadata,
+) -> *mut c_char {
+    let metadata = ztensor_handle!(metadata_ptr);
+    match &metadata.checksum {
+        Some(s) => to_cstring(s.clone()),
+        None => ptr::null_mut(),
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_get_shape_len(metadata_ptr: *const CTensorMetadata) -> size_t {
+    let metadata = ztensor_handle!(metadata_ptr, 0);
+    metadata.shape.len()
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_get_shape_data(
+    metadata_ptr: *const CTensorMetadata,
+) -> *mut u64 {
+    let metadata = ztensor_handle!(metadata_ptr);
+    let mut shape_vec = metadata.shape.clone();
+    let ptr = shape_vec.as_mut_ptr();
+    std::mem::forget(shape_vec);
+    ptr
+}
+
+// --- Memory Management API ---
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_reader_free(reader_ptr: *mut CZTensorReader) {
+    if !reader_ptr.is_null() {
+        let _ = unsafe { Box::from_raw(reader_ptr) };
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_writer_free(writer_ptr: *mut CZTensorWriter) {
+    if !writer_ptr.is_null() {
+        let _ = unsafe { Box::from_raw(writer_ptr) };
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_metadata_free(metadata_ptr: *mut CTensorMetadata) {
+    if !metadata_ptr.is_null() {
+        let _ = unsafe { Box::from_raw(metadata_ptr) };
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_free_tensor_view(view_ptr: *mut CTensorDataView) {
+    if !view_ptr.is_null() {
+        unsafe {
+            let view = Box::from_raw(view_ptr);
+            // This reconstitutes the `Vec<u8>` and allows it to be dropped.
+            let _ = Box::from_raw(view._owner as *mut Vec<u8>);
+        }
+    }
+}
 
 #[unsafe(no_mangle)]
 pub extern "C" fn ztensor_free_string(s: *mut c_char) {
     if !s.is_null() {
-        unsafe {
-            let _ = CString::from_raw(s);
-        };
+        let _ = unsafe { CString::from_raw(s) };
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_free_string_array(arr_ptr: *mut CStringArray) {
+    if arr_ptr.is_null() {
+        return;
+    }
+    unsafe {
+        let arr = Box::from_raw(arr_ptr);
+        let strings = Vec::from_raw_parts(arr.strings, arr.len, arr.len);
+        for s_ptr in strings {
+            let _ = CString::from_raw(s_ptr);
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn ztensor_free_u64_array(ptr: *mut u64, len: size_t) {
+    if !ptr.is_null() {
+        let _ = unsafe { Vec::from_raw_parts(ptr, len, len) };
     }
 }