safetensors 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7e6ec72940990e896207a173be53e68952eb12c8ad8b4f4c3bd707fabee4944
-  data.tar.gz: aa06b8480be369bb75db42d3eab5b3d139194d74aa8bad6580f5f71dd4351514
+  metadata.gz: cc628696f449fb899f85e95c1c824c00b832aad7e3f92253bdc48c9c1e30c3af
+  data.tar.gz: 433d331c6cfaadcc05a844d7fb8a1e31681b626bcedadc6fdc653960a0cfc578
 SHA512:
-  metadata.gz: 4086269deb609530821fe5b3257be0c1deedfcc9be19469c8552afb9b86cbfec32ad40160ab761ab5bea082dca7fc05cc22fe3a04a0de604ae37b916e309c21f
-  data.tar.gz: 7edf607e6a2ff87b4844d50a2ef5a5a629db6aa87a522d9a771559a8f6ed35ed5094f59bfde6d6491f39c914b295606e2a97a09d113ae621ee0e8a78ff7e0329
+  metadata.gz: d05099bbce87c9cfe6634ed567378a8e135b3e1c72d6aa541d6ba2c8452ff3a65e249bd460d8490d8b525c01ae6269aafd75d07d07c3a40fedea9418eb7f79a3
+  data.tar.gz: 688f2f91a2f340a82dc8e11d73428e2bb6bfb66e2f15f67e24b7e31117582617b82d106f973cb152395cd4de07172bb48a304d0febd196daefa234cd45ac4980

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.3.0 (2026-06-09)
+
+- Updated Safetensors to 0.8.0
+- Added support for releasing GVL
+- Dropped support for Ruby < 3.3
+
 ## 0.2.2 (2026-01-05)
 
 - Added support for Ruby 4.0

data/Cargo.lock

@@ -81,12 +81,40 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
 [[package]]
 name = "foldhash"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
 [[package]]
 name = "glob"
 version = "0.3.2"
@@ -148,6 +176,12 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "linux-raw-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+
 [[package]]
 name = "magnus"
 version = "0.8.1"
@@ -179,9 +213,9 @@ checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
 
 [[package]]
 name = "memmap2"
-version = "0.5.10"
+version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3"
 dependencies = [
  "libc",
 ]
@@ -202,6 +236,12 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.95"
@@ -220,6 +260,12 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
 [[package]]
 name = "rb-sys"
 version = "0.9.124"
@@ -285,6 +331,19 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustix"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
 [[package]]
 name = "ryu"
 version = "1.0.20"
@@ -293,21 +352,24 @@ checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
 [[package]]
 name = "safetensors"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "675656c1eabb620b921efea4f9199f97fc86e36dd6ffd1fbbe48d0f59a4987f5"
+checksum = "79b079b829cb27a1c3c374341345ed2e8b2c0c839034522cee576c140bd7f846"
 dependencies = [
  "hashbrown",
+ "libc",
  "serde",
  "serde_json",
+ "tempfile",
 ]
 
 [[package]]
 name = "safetensors-ruby"
-version = "0.2.2"
+version = "0.3.0"
 dependencies = [
  "magnus",
  "memmap2",
+ "rb-sys",
  "safetensors",
  "serde_json",
 ]
@@ -373,12 +435,49 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "tempfile"
+version = "3.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
+dependencies = [
+ "fastrand",
+ "getrandom",
+ "once_cell",
+ "rustix",
+ "windows-sys",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
+[[package]]
+name = "wasip2"
+version = "1.0.3+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.53.2"
@@ -442,3 +541,9 @@ name = "windows_x86_64_msvc"
 version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"

data/README.md

@@ -2,7 +2,7 @@
 
 :slightly_smiling_face: Simple, [safe way](https://github.com/huggingface/safetensors) to store and distribute tensors
 
-Supports [Torch.rb](https://github.com/ankane/torch.rb) and [Numo](https://github.com/ruby-numo/numo-narray)
+Supports [Torch.rb](https://github.com/ankane/torch.rb) and [numo-narray-alt](https://github.com/yoshoku/numo-narray-alt)
 
 [![Build Status](https://github.com/ankane/safetensors-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ankane/safetensors-ruby/actions)
 

data/ext/safetensors/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "safetensors-ruby"
-version = "0.2.2"
+version = "0.3.0"
 license = "Apache-2.0"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
@@ -13,6 +13,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 magnus = "0.8"
-memmap2 = "0.5"
-safetensors = "=0.7.0"
+memmap2 = "0.9"
+rb-sys = "0.9"
+safetensors = "=0.8.0"
 serde_json = "1"

data/ext/safetensors/src/lib.rs

@@ -1,76 +1,125 @@
+mod ruby;
+
+use core::slice;
 use magnus::{
     function, kwargs, method, prelude::*, r_hash::ForEach, Error, IntoValue, RArray, RHash,
     RModule, RString, Ruby, Symbol, TryConvert, Value,
 };
 use memmap2::{Mmap, MmapOptions};
-use safetensors::tensor::{Dtype, Metadata, SafeTensors, TensorView};
+use safetensors::tensor::{Dtype, Metadata, SafeTensors};
+use safetensors::View;
+use std::borrow::Cow;
 use std::collections::HashMap;
+use std::fmt;
 use std::fs::File;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use crate::ruby::GvlExt;
+
 type RbResult<T> = Result<T, Error>;
 
-fn prepare(tensor_dict: &RHash) -> RbResult<HashMap<String, TensorView<'_>>> {
+#[derive(Clone, Debug)]
+struct TensorSpec {
+    dtype: Dtype,
+    shape: Vec<usize>,
+    data_ptr: u64,
+    data_len: usize,
+}
+
+impl TensorSpec {
+    fn new(dtype: &str, shape: Vec<usize>, data_ptr: u64, data_len: usize) -> RbResult<Self> {
+        let dtype = parse_dtype_str(dtype)?;
+        let mut shape = shape;
+        // F4 packs two elements per byte; the safetensors header records the
+        // logical element count, so double the last dim.
+        if dtype == Dtype::F4 && !shape.is_empty() {
+            let n = shape.len();
+            shape[n - 1] = shape[n - 1].checked_mul(2).ok_or_else(|| {
+                SafetensorError::new_err(format!(
+                    "F4 last-dim {} doubled to logical shape overflows usize",
+                    shape[n - 1]
+                ))
+            })?;
+        }
+        Ok(Self {
+            dtype,
+            shape,
+            data_ptr,
+            data_len,
+        })
+    }
+}
+
+impl View for &TensorSpec {
+    fn dtype(&self) -> Dtype {
+        self.dtype
+    }
+
+    fn shape(&self) -> &[usize] {
+        &self.shape
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        let p = self.data_ptr as *const u8;
+        // SAFETY: validated by the caller; see the struct-level safety note.
+        unsafe {
+            let slice = slice::from_raw_parts(p, self.data_len);
+            Cow::Borrowed(slice)
+        }
+    }
+
+    fn data_len(&self) -> usize {
+        self.data_len
+    }
+}
+
+fn parse_dtype_str(dtype: &str) -> RbResult<Dtype> {
+    Ok(match dtype {
+        "bool" => Dtype::BOOL,
+        "int8" => Dtype::I8,
+        "uint8" => Dtype::U8,
+        "int16" => Dtype::I16,
+        "uint16" => Dtype::U16,
+        "int32" => Dtype::I32,
+        "uint32" => Dtype::U32,
+        "int64" => Dtype::I64,
+        "uint64" => Dtype::U64,
+        "float16" => Dtype::F16,
+        "float32" => Dtype::F32,
+        "float64" => Dtype::F64,
+        "bfloat16" => Dtype::BF16,
+        "float8_e4m3fn" => Dtype::F8_E4M3,
+        "float8_e4m3fnuz" => Dtype::F8_E4M3FNUZ,
+        "float8_e5m2" => Dtype::F8_E5M2,
+        "float8_e5m2fnuz" => Dtype::F8_E5M2FNUZ,
+        "float8_e8m0fnu" => Dtype::F8_E8M0,
+        "float4_e2m1fn_x2" => Dtype::F4,
+        "complex64" => Dtype::C64,
+        other => {
+            return Err(SafetensorError::new_err(format!(
+                "Unknown dtype {other:?}. Supported dtypes: bool, int8, uint8, int16, uint16, \
+                 int32, uint32, int64, uint64, float16, float32, float64, bfloat16, \
+                 float8_e4m3fn, float8_e4m3fnuz, float8_e5m2, float8_e5m2fnuz, float8_e8m0fnu, \
+                 float4_e2m1fn_x2, complex64",
+            )));
+        }
+    })
+}
+
+fn prepare(tensor_dict: &RHash) -> RbResult<HashMap<String, TensorSpec>> {
     let mut tensors = HashMap::with_capacity(tensor_dict.len());
     tensor_dict.foreach(|tensor_name: String, tensor_desc: RHash| {
-        let mut shape: Option<Vec<usize>> = None;
-        let mut dtype: Option<Dtype> = None;
-        let mut data: Option<(*const u8, usize)> = None;
-
-        tensor_desc.foreach(|key: String, value: Value| {
-            match key.as_str() {
-                "shape" => shape = Some(Vec::try_convert(value)?),
-                "dtype" => {
-                    let value = String::try_convert(value)?;
-                    dtype = match value.as_str() {
-                        "bool" => Some(Dtype::BOOL),
-                        "int8" => Some(Dtype::I8),
-                        "uint8" => Some(Dtype::U8),
-                        "int16" => Some(Dtype::I16),
-                        "uint16" => Some(Dtype::U16),
-                        "int32" => Some(Dtype::I32),
-                        "uint32" => Some(Dtype::U32),
-                        "int64" => Some(Dtype::I64),
-                        "uint64" => Some(Dtype::U64),
-                        "float16" => Some(Dtype::F16),
-                        "float32" => Some(Dtype::F32),
-                        "float64" => Some(Dtype::F64),
-                        "bfloat16" => Some(Dtype::BF16),
-                        "float8_e4m3fn" => Some(Dtype::F8_E4M3),
-                        "float8_e5m2" => Some(Dtype::F8_E5M2),
-                        dtype_str => {
-                            return Err(SafetensorError::new_err(format!(
-                                "dtype {dtype_str} is not covered",
-                            )));
-                        }
-                    }
-                }
-                "data" => {
-                    let rs = RString::try_convert(value)?;
-                    // SAFETY: No context switching between threads in native extensions
-                    // so the string will not be modified (or garbage collected)
-                    // while the reference is held. Also, the string is a private copy.
-                    let slice = unsafe { rs.as_slice() };
-                    data = Some((slice.as_ptr(), slice.len()));
-                }
-                _ => println!("Ignored unknown kwarg option {key}"),
-            };
-
-            Ok(ForEach::Continue)
-        })?;
-        let shape = shape.ok_or_else(|| {
-            SafetensorError::new_err(format!("Missing `shape` in {tensor_desc:?}"))
-        })?;
-        let dtype = dtype.ok_or_else(|| {
-            SafetensorError::new_err(format!("Missing `dtype` in {tensor_desc:?}"))
-        })?;
-        let data = data.ok_or_else(|| {
-            SafetensorError::new_err(format!("Missing `data` in {tensor_desc:?}"))
-        })?;
-        // SAFETY: See comment above.
-        let data = unsafe { std::slice::from_raw_parts(data.0, data.1) };
-        let tensor = TensorView::new(dtype, shape, data)
+        let dtype: String = tensor_desc.aref("dtype")?;
+        let shape: Vec<usize> = tensor_desc.aref("shape")?;
+        let data: RString = tensor_desc.aref("data")?;
+
+        // SAFETY: No context switching between threads in native extensions
+        // so the string will not be modified (or garbage collected)
+        // while the reference is held. Also, the string is a private copy.
+        let slice = unsafe { data.as_slice() };
+
+        let tensor = TensorSpec::new(dtype.as_ref(), shape, slice.as_ptr() as u64, slice.len())
             .map_err(|e| SafetensorError::new_err(format!("Error preparing tensor view: {e:?}")))?;
         tensors.insert(tensor_name, tensor);
 
@@ -86,19 +135,21 @@ fn serialize(
 ) -> RbResult<RString> {
     let tensors = prepare(&tensor_dict)?;
     let metadata_map = metadata.map(HashMap::from_iter);
-    let out = safetensors::tensor::serialize(&tensors, metadata_map)
+    let out = ruby
+        .detach(|| safetensors::tensor::serialize(&tensors, metadata_map))
         .map_err(|e| SafetensorError::new_err(format!("Error while serializing: {e:?}")))?;
     let rbbytes = ruby.str_from_slice(&out);
     Ok(rbbytes)
 }
 
 fn serialize_file(
+    ruby: &Ruby,
     tensor_dict: RHash,
     filename: PathBuf,
     metadata: Option<HashMap<String, String>>,
 ) -> RbResult<()> {
     let tensors = prepare(&tensor_dict)?;
-    safetensors::tensor::serialize_to_file(&tensors, metadata, filename.as_path())
+    ruby.detach(|| safetensors::tensor::serialize_to_file(&tensors, metadata, filename.as_path()))
         .map_err(|e| SafetensorError::new_err(format!("Error while serializing: {e:?}")))?;
     Ok(())
 }
@@ -132,6 +183,15 @@ enum Framework {
     Numo,
 }
 
+impl fmt::Display for Framework {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match *self {
+            Framework::Pytorch => "torch",
+            Framework::Numo => "numo",
+        })
+    }
+}
+
 impl TryConvert for Framework {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let name: String = String::try_convert(ob)?;
@@ -157,56 +217,64 @@ enum Device {
     Mps,
     Npu(usize),
     Xpu(usize),
+    Xla(usize),
+    Mlu(usize),
+    Hpu(usize),
+    Anonymous(usize),
+}
+
+impl fmt::Display for Device {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Device::Cpu => write!(f, "cpu"),
+            Device::Mps => write!(f, "mps"),
+            Device::Cuda(index) => write!(f, "cuda:{index}"),
+            Device::Npu(index) => write!(f, "npu:{index}"),
+            Device::Xpu(index) => write!(f, "xpu:{index}"),
+            Device::Xla(index) => write!(f, "xla:{index}"),
+            Device::Mlu(index) => write!(f, "mlu:{index}"),
+            Device::Hpu(index) => write!(f, "hpu:{index}"),
+            Device::Anonymous(index) => write!(f, "{index}"),
+        }
+    }
+}
+
+/// Parsing the device index.
+fn parse_device(name: &str) -> RbResult<usize> {
+    let tokens: Vec<_> = name.split(':').collect();
+    if tokens.len() == 2 {
+        Ok(tokens[1].parse().map_err(SafetensorError::parse)?)
+    } else {
+        Err(SafetensorError::new_err(format!(
+            "device {name} is invalid"
+        )))
+    }
 }
 
 impl TryConvert for Device {
     fn try_convert(ob: Value) -> RbResult<Self> {
         if let Ok(name) = String::try_convert(ob) {
-            match &name[..] {
+            match name.as_str() {
                 "cpu" => Ok(Device::Cpu),
                 "cuda" => Ok(Device::Cuda(0)),
                 "mps" => Ok(Device::Mps),
                 "npu" => Ok(Device::Npu(0)),
                 "xpu" => Ok(Device::Xpu(0)),
-                name if name.starts_with("cuda:") => {
-                    let tokens: Vec<_> = name.split(':').collect();
-                    if tokens.len() == 2 {
-                        let device: usize = tokens[1].parse().map_err(SafetensorError::parse)?;
-                        Ok(Device::Cuda(device))
-                    } else {
-                        Err(SafetensorError::new_err(format!(
-                            "device {name} is invalid"
-                        )))
-                    }
-                }
-                name if name.starts_with("npu:") => {
-                    let tokens: Vec<_> = name.split(':').collect();
-                    if tokens.len() == 2 {
-                        let device: usize = tokens[1].parse().map_err(SafetensorError::parse)?;
-                        Ok(Device::Npu(device))
-                    } else {
-                        Err(SafetensorError::new_err(format!(
-                            "device {name} is invalid"
-                        )))
-                    }
-                }
-                name if name.starts_with("xpu:") => {
-                    let tokens: Vec<_> = name.split(':').collect();
-                    if tokens.len() == 2 {
-                        let device: usize = tokens[1].parse().map_err(SafetensorError::parse)?;
-                        Ok(Device::Xpu(device))
-                    } else {
-                        Err(SafetensorError::new_err(format!(
-                            "device {name} is invalid"
-                        )))
-                    }
-                }
+                "xla" => Ok(Device::Xla(0)),
+                "mlu" => Ok(Device::Mlu(0)),
+                "hpu" => Ok(Device::Hpu(0)),
+                name if name.starts_with("cuda:") => parse_device(name).map(Device::Cuda),
+                name if name.starts_with("npu:") => parse_device(name).map(Device::Npu),
+                name if name.starts_with("xpu:") => parse_device(name).map(Device::Xpu),
+                name if name.starts_with("xla:") => parse_device(name).map(Device::Xla),
+                name if name.starts_with("mlu:") => parse_device(name).map(Device::Mlu),
+                name if name.starts_with("hpu:") => parse_device(name).map(Device::Hpu),
                 name => Err(SafetensorError::new_err(format!(
                     "device {name} is invalid"
                 ))),
             }
         } else if let Ok(number) = usize::try_convert(ob) {
-            Ok(Device::Cuda(number))
+            Ok(Device::Anonymous(number))
         } else {
             Err(SafetensorError::new_err(format!("device {ob} is invalid")))
         }
@@ -221,6 +289,10 @@ impl IntoValue for Device {
             Device::Mps => "mps".into_value_with(ruby),
             Device::Npu(n) => format!("npu:{n}").into_value_with(ruby),
             Device::Xpu(n) => format!("xpu:{n}").into_value_with(ruby),
+            Device::Xla(n) => format!("xla:{n}").into_value_with(ruby),
+            Device::Mlu(n) => format!("mlu:{n}").into_value_with(ruby),
+            Device::Hpu(n) => format!("hpu:{n}").into_value_with(ruby),
+            Device::Anonymous(n) => n.into_value_with(ruby),
         }
     }
 }
@@ -240,13 +312,13 @@ struct Open {
 impl Open {
     fn new(filename: PathBuf, framework: Framework, device: Option<Device>) -> RbResult<Self> {
         let file = File::open(&filename).map_err(|_| {
-            SafetensorError::new_err(format!("No such file or directory: {filename:?}"))
+            SafetensorError::new_err(format!("No such file or directory: {}", filename.display()))
         })?;
         let device = device.unwrap_or(Device::Cpu);
 
         if device != Device::Cpu && framework != Framework::Pytorch {
             return Err(SafetensorError::new_err(format!(
-                "Device {device:?} is not support for framework {framework:?}",
+                "Device {device} is not support for framework {framework}",
             )));
         }
 
@@ -255,7 +327,7 @@ impl Open {
         let buffer = unsafe { MmapOptions::new().map(&file).map_err(SafetensorError::io)? };
 
         let (n, metadata) = SafeTensors::read_metadata(&buffer).map_err(|e| {
-            SafetensorError::new_err(format!("Error while deserializing header: {e:?}"))
+            SafetensorError::new_err(format!("Error while deserializing header: {e}"))
         })?;
 
         let offset = n + 8;
@@ -285,7 +357,7 @@ impl Open {
 
     pub fn get_tensor(&self, ruby: &Ruby, name: &str) -> RbResult<Value> {
         let info = self.metadata.info(name).ok_or_else(|| {
-            SafetensorError::new_err(format!("File does not contain tensor {name}",))
+            SafetensorError::new_err(format!("File does not contain tensor {name}"))
         })?;
 
         match &self.storage.as_ref() {
@@ -357,7 +429,7 @@ fn create_tensor(
                 .map_err(|_| SafetensorError::new_err("Torch not loaded".into()))?,
             false,
         ),
-        _ => (
+        Framework::Numo => (
             ruby.class_object()
                 .const_get("Numo")
                 .map_err(|_| SafetensorError::new_err("Numo not loaded".into()))?,
@@ -375,7 +447,7 @@ fn create_tensor(
             )?;
             module.funcall("_from_blob_ref", (array, shape, options))?
         }
-        _ => {
+        Framework::Numo => {
             let class: Value = module.funcall("const_get", (dtype,))?;
             class.funcall("from_binary", (array, shape))?
         }
@@ -419,6 +491,10 @@ fn get_rbdtype(ruby: &Ruby, _module: RModule, dtype: Dtype, is_numo: bool) -> Rb
             Dtype::BOOL => ruby.to_symbol("bool"),
             Dtype::F8_E4M3 => ruby.to_symbol("float8_e4m3fn"),
             Dtype::F8_E5M2 => ruby.to_symbol("float8_e5m2"),
+            Dtype::F8_E5M2FNUZ => ruby.to_symbol("float8_e5m2fnuz"),
+            Dtype::F8_E8M0 => ruby.to_symbol("float8_e8m0fnu"),
+            Dtype::F4 => ruby.to_symbol("float4_e2m1fn_x2"),
+            Dtype::C64 => ruby.to_symbol("complex64"),
             dtype => {
                 return Err(SafetensorError::new_err(format!(
                     "Dtype not understood: {dtype:?}"

data/ext/safetensors/src/ruby.rs

@@ -0,0 +1,51 @@
+use std::ffi::c_void;
+use std::ptr::null_mut;
+
+use magnus::Ruby;
+use rb_sys::rb_thread_call_without_gvl;
+
+pub trait GvlExt {
+    fn detach<T, F>(&self, func: F) -> T
+    where
+        F: Send + FnOnce() -> T,
+        T: Send;
+}
+
+impl GvlExt for Ruby {
+    fn detach<T, F>(&self, func: F) -> T
+    where
+        F: Send + FnOnce() -> T,
+        T: Send,
+    {
+        let mut data = CallbackData {
+            func: Some(func),
+            result: None,
+        };
+
+        unsafe {
+            rb_thread_call_without_gvl(
+                Some(call_without_gvl::<F, T>),
+                &mut data as *mut _ as *mut c_void,
+                None,
+                null_mut(),
+            );
+        }
+
+        data.result.unwrap()
+    }
+}
+
+struct CallbackData<F, T> {
+    func: Option<F>,
+    result: Option<T>,
+}
+
+extern "C" fn call_without_gvl<F, T>(data: *mut c_void) -> *mut c_void
+where
+    F: FnOnce() -> T,
+{
+    let data = unsafe { &mut *(data as *mut CallbackData<F, T>) };
+    let func = data.func.take().unwrap();
+    data.result = Some(func());
+    null_mut()
+}

data/lib/safetensors/version.rb

@@ -1,3 +1,3 @@
 module Safetensors
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: safetensors
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -37,6 +37,7 @@ files:
 - ext/safetensors/Cargo.toml
 - ext/safetensors/extconf.rb
 - ext/safetensors/src/lib.rs
+- ext/safetensors/src/ruby.rs
 - lib/safetensors.rb
 - lib/safetensors/numo.rb
 - lib/safetensors/torch.rb
@@ -52,14 +53,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Simple, safe way to store and distribute tensors
 test_files: []