red-candle 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e41612741efd4ec156c530c9d68edc5c860c17067123da37c06adbe1792442ef
-  data.tar.gz: ff3c39bd45b9c2801278ba56feec00ec72634c6ac71318f6eac13ec7e18fa70e
+  metadata.gz: 7a3ac57ccd28cb2eb647c5a71f42fdbdf84a9dcaabd906165daca3d57c4a8eb0
+  data.tar.gz: 283104e93802ac97f11525226c9e41dc3bebccb8706d5b69a6a648d62cf2ccad
 SHA512:
-  metadata.gz: d90e48980e392174a2f2630feaaf3d7e735ef055e417fc8a5a9edeb3f3dda5ec3b7a99240145825da2bf6dd0a032c4afc24f67da2e3668a93950c069c1648824
-  data.tar.gz: 8feb63ed8818782bad6ba76591ae36f930b14421b75c2bfe69206ceba673074585f37c84c43d16738fc80d5e6110617a34bd4693b98dea80c2c6d6fdf6436e1c
+  metadata.gz: d5be5ca76fe5441ee1fd87ea83bcd02f5a630c3410a4dccc347da28290ef408c4c2cae428134f2a8fba839fe5aacf2b7593fe45274c967600e6684d09f212a01
+  data.tar.gz: 72289aaf0c17dea679acfa4f92be5371f2543293e27dab0752b39c77a1c2be98c480c0ce7266bc07519551770abdf53fdbbf0f4d3c1fdf6ba928c2452e598060

data/Cargo.lock

@@ -167,7 +167,7 @@ dependencies = [
  "bitflags 2.9.4",
  "cexpr",
  "clang-sys",
- "itertools 0.12.1",
+ "itertools 0.11.0",
  "lazy_static",
  "lazycell",
  "proc-macro2",
@@ -1750,15 +1750,6 @@ dependencies = [
  "either",
 ]
 
-[[package]]
-name = "itertools"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -1890,9 +1881,9 @@ checksum = "670fdfda89751bc4a84ac13eaa63e205cf0fd22b4c9a5fbfa085b63c1f1d3a30"
 
 [[package]]
 name = "magnus"
-version = "0.7.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d87ae53030f3a22e83879e666cb94e58a7bdf31706878a0ba48752994146dab"
+checksum = "3b36a5b126bbe97eb0d02d07acfeb327036c6319fd816139a49824a83b7f9012"
 dependencies = [
  "magnus-macros",
  "rb-sys",
@@ -1902,9 +1893,9 @@ dependencies = [
 
 [[package]]
 name = "magnus-macros"
-version = "0.6.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5968c820e2960565f647819f5928a42d6e874551cab9d88d75e3e0660d7f71e3"
+checksum = "47607461fd8e1513cb4f2076c197d8092d921a1ea75bd08af97398f593751892"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2656,18 +2647,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.117"
+version = "0.9.124"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f900d1ce4629a2ebffaf5de74bd8f9c1188d4c5ed406df02f97e22f77a006f44"
+checksum = "c85c4188462601e2aa1469def389c17228566f82ea72f137ed096f21591bc489"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.117"
+version = "0.9.124"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef1e9c857028f631056bcd6d88cec390c751e343ce2223ddb26d23eb4a151d59"
+checksum = "568068db4102230882e6d4ae8de6632e224ca75fe5970f6e026a04e91ed635d3"
 dependencies = [
  "bindgen 0.69.5",
  "lazy_static",
@@ -2680,9 +2671,9 @@ dependencies = [
 
 [[package]]
 name = "rb-sys-env"
-version = "0.1.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a35802679f07360454b418a5d1735c89716bde01d35b1560fc953c1415a0b3bb"
+checksum = "cca7ad6a7e21e72151d56fe2495a259b5670e204c3adac41ee7ef676ea08117a"
 
 [[package]]
 name = "reborrow"

data/ext/candle/Cargo.toml

@@ -15,7 +15,7 @@ candle-transformers = { version = "0.9.1" }
 tokenizers = { version = "0.22.0", default-features = true, features = ["fancy-regex"] }
 hf-hub = "0.4.1"
 half = "2.6.0"
-magnus = "0.7.1"
+magnus = "0.8"
 safetensors = "0.3"
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }

data/ext/candle/src/ruby/device.rs

@@ -1,5 +1,5 @@
 use magnus::Error;
-use magnus::{function, method, class, RModule, Module, Object};
+use magnus::{function, method, RModule, Module, Object, Ruby};
 
 use ::candle_core::Device as CoreDevice;
 use crate::ruby::Result;
@@ -101,7 +101,7 @@ impl Device {
         #[cfg(not(feature = "cuda"))]
         {
             return Err(Error::new(
-                magnus::exception::runtime_error(),
+                Ruby::get().unwrap().exception_runtime_error(),
                 "CUDA support not compiled in. Rebuild with CUDA available.",
             ));
         }
@@ -115,7 +115,7 @@ impl Device {
         #[cfg(not(feature = "metal"))]
         {
             return Err(Error::new(
-                magnus::exception::runtime_error(),
+                Ruby::get().unwrap().exception_runtime_error(),
                 "Metal support not compiled in. Rebuild on macOS.",
             ));
         }
@@ -139,7 +139,7 @@ impl Device {
                 #[cfg(not(feature = "cuda"))]
                 {
                     return Err(Error::new(
-                        magnus::exception::runtime_error(),
+                        Ruby::get().unwrap().exception_runtime_error(),
                         "CUDA support not compiled in. Rebuild with CUDA available.",
                     ));
                 }
@@ -161,7 +161,7 @@ impl Device {
                 #[cfg(not(feature = "metal"))]
                 {
                     return Err(Error::new(
-                        magnus::exception::runtime_error(),
+                        Ruby::get().unwrap().exception_runtime_error(),
                         "Metal support not compiled in. Rebuild on macOS.",
                     ));
                 }
@@ -211,14 +211,15 @@ impl magnus::TryConvert for Device {
             "cpu" => Device::Cpu,
             "cuda" => Device::Cuda,
             "metal" => Device::Metal,
-            _ => return Err(Error::new(magnus::exception::arg_error(), "invalid device")),
+            _ => return Err(Error::new(Ruby::get().unwrap().exception_arg_error(), "invalid device")),
         };
         Ok(device)
     }
 }
 
 pub fn init(rb_candle: RModule) -> Result<()> {
-    let rb_device = rb_candle.define_class("Device", class::object())?;
+    let ruby = Ruby::get().unwrap();
+    let rb_device = rb_candle.define_class("Device", ruby.class_object())?;
     rb_device.define_singleton_method("cpu", function!(Device::cpu, 0))?;
     rb_device.define_singleton_method("cuda", function!(Device::cuda, 0))?;
     rb_device.define_singleton_method("metal", function!(Device::metal, 0))?;

data/ext/candle/src/ruby/dtype.rs

@@ -1,5 +1,5 @@
 use magnus::value::ReprValue;
-use magnus::{method, class, RModule, Module};
+use magnus::{method, RModule, Module, Ruby};
 
 use ::candle_core::DType as CoreDType;
 use crate::ruby::Result;
@@ -30,7 +30,8 @@ impl DType {
 }
 
 pub fn init(rb_candle: RModule) -> Result<()> {
-    let rb_dtype = rb_candle.define_class("DType", class::object())?;
+    let ruby = Ruby::get().unwrap();
+    let rb_dtype = rb_candle.define_class("DType", ruby.class_object())?;
     rb_dtype.define_method("to_s", method!(DType::__str__, 0))?;
     rb_dtype.define_method("inspect", method!(DType::__repr__, 0))?;
     Ok(())

data/ext/candle/src/ruby/embedding_model.rs

@@ -13,7 +13,7 @@ use candle_transformers::models::{
     jina_bert::{BertModel as JinaBertModel, Config as JinaConfig},
     distilbert::{DistilBertModel, Config as DistilBertConfig}
 };
-use magnus::{class, function, method, prelude::*, Error, RModule, RHash};
+use magnus::{function, method, prelude::*, Error, RModule, RHash, Ruby};
 use std::path::Path;
 use serde_json;
 
@@ -103,28 +103,30 @@ impl EmbeddingModel {
     /// &RETURNS&: Tensor
     /// pooling_method: "pooled", "pooled_normalized", or "cls" (default: "pooled")
     pub fn embedding(&self, input: String, pooling_method: String) -> Result<Tensor> {
+        let ruby = Ruby::get().unwrap();
         match &self.0.model {
             Some(model) => {
                 match &self.0.tokenizer {
                     Some(tokenizer) => Ok(Tensor(self.compute_embedding(input, model, tokenizer, &pooling_method)?)),
-                    None => Err(magnus::Error::new(magnus::exception::runtime_error(), "Tokenizer not found"))
+                    None => Err(magnus::Error::new(ruby.exception_runtime_error(), "Tokenizer not found"))
                 }
             }
-            None => Err(magnus::Error::new(magnus::exception::runtime_error(), "Model not found"))
+            None => Err(magnus::Error::new(ruby.exception_runtime_error(), "Model not found"))
         }
     }
 
     /// Returns the unpooled embedding tensor ([1, SEQLENGTH, DIM]) for the input text
     /// &RETURNS&: Tensor
     pub fn embeddings(&self, input: String) -> Result<Tensor> {
+        let ruby = Ruby::get().unwrap();
         match &self.0.model {
             Some(model) => {
                 match &self.0.tokenizer {
                     Some(tokenizer) => Ok(Tensor(self.compute_embeddings(input, model, tokenizer)?)),
-                    None => Err(magnus::Error::new(magnus::exception::runtime_error(), "Tokenizer not found"))
+                    None => Err(magnus::Error::new(ruby.exception_runtime_error(), "Tokenizer not found"))
                 }
             }
-            None => Err(magnus::Error::new(magnus::exception::runtime_error(), "Model not found"))
+            None => Err(magnus::Error::new(ruby.exception_runtime_error(), "Model not found"))
         }
     }
 
@@ -165,7 +167,10 @@ impl EmbeddingModel {
                     },
                     Err(_) => None
                 };
-                inferred_emb_dim.ok_or_else(|| magnus::Error::new(magnus::exception::runtime_error(), "Could not infer embedding size from model file. Please specify embedding_size explicitly."))
+                inferred_emb_dim.ok_or_else(|| {
+                    let ruby = Ruby::get().unwrap();
+                    magnus::Error::new(ruby.exception_runtime_error(), "Could not infer embedding size from model file. Please specify embedding_size explicitly.")
+                })
             }
         }
     }
@@ -178,8 +183,9 @@ impl EmbeddingModel {
             EmbeddingModelType::JinaBert => {
                 let model_path = api.repo(repo).get("model.safetensors").map_err(wrap_hf_err)?;
                 if !std::path::Path::new(&model_path).exists() {
+                    let ruby = Ruby::get().unwrap();
                     return Err(magnus::Error::new(
-                        magnus::exception::runtime_error(),
+                        ruby.exception_runtime_error(),
                         "model.safetensors not found after download. Only safetensors models are supported. Please ensure your model repo contains model.safetensors."
                     ));
                 }
@@ -196,8 +202,9 @@ impl EmbeddingModel {
             EmbeddingModelType::StandardBert => {
                 let model_path = api.repo(repo).get("model.safetensors").map_err(wrap_hf_err)?;
                 if !std::path::Path::new(&model_path).exists() {
+                    let ruby = Ruby::get().unwrap();
                     return Err(magnus::Error::new(
-                        magnus::exception::runtime_error(),
+                        ruby.exception_runtime_error(),
                         "model.safetensors not found after download. Only safetensors models are supported. Please ensure your model repo contains model.safetensors."
                     ));
                 }
@@ -214,8 +221,9 @@ impl EmbeddingModel {
             EmbeddingModelType::DistilBert => {
                 let model_path = api.repo(repo.clone()).get("model.safetensors").map_err(wrap_hf_err)?;
                 if !std::path::Path::new(&model_path).exists() {
+                    let ruby = Ruby::get().unwrap();
                     return Err(magnus::Error::new(
-                        magnus::exception::runtime_error(),
+                        ruby.exception_runtime_error(),
                         "model.safetensors not found after download. Only safetensors models are supported. Please ensure your model repo contains model.safetensors."
                     ));
                 }
@@ -235,8 +243,9 @@ impl EmbeddingModel {
             EmbeddingModelType::MiniLM => {
                 let model_path = api.repo(repo.clone()).get("model.safetensors").map_err(wrap_hf_err)?;
                 if !std::path::Path::new(&model_path).exists() {
+                    let ruby = Ruby::get().unwrap();
                     return Err(magnus::Error::new(
-                        magnus::exception::runtime_error(),
+                        ruby.exception_runtime_error(),
                         "model.safetensors not found after download. Only safetensors models are supported. Please ensure your model repo contains model.safetensors."
                     ));
                 }
@@ -357,7 +366,10 @@ impl EmbeddingModel {
             "pooled" => Self::pooled_embedding(&result),
             "pooled_normalized" => Self::pooled_normalized_embedding(&result),
             "cls" => Self::pooled_cls_embedding(&result),
-            _ => Err(magnus::Error::new(magnus::exception::runtime_error(), "Unknown pooling method")),
+            _ => {
+                let ruby = Ruby::get().unwrap();
+                Err(magnus::Error::new(ruby.exception_runtime_error(), "Unknown pooling method"))
+            },
         }
     }
 
@@ -390,7 +402,10 @@ impl EmbeddingModel {
     pub fn tokenizer(&self) -> Result<crate::ruby::tokenizer::Tokenizer> {
         match &self.0.tokenizer {
             Some(tokenizer) => Ok(crate::ruby::tokenizer::Tokenizer(tokenizer.clone())),
-            None => Err(magnus::Error::new(magnus::exception::runtime_error(), "No tokenizer loaded for this model"))
+            None => {
+                let ruby = Ruby::get().unwrap();
+                Err(magnus::Error::new(ruby.exception_runtime_error(), "No tokenizer loaded for this model"))
+            }
         }
     }
     
@@ -409,7 +424,8 @@ impl EmbeddingModel {
     
     /// Get all options as a hash
     pub fn options(&self) -> Result<RHash> {
-        let hash = RHash::new();
+        let ruby = Ruby::get().unwrap();
+        let hash = ruby.hash_new();
         
         // Add model_id
         if let Some(model_id) = &self.0.model_id {
@@ -439,7 +455,8 @@ impl EmbeddingModel {
 }
 
 pub fn init(rb_candle: RModule) -> Result<()> {
-    let rb_embedding_model = rb_candle.define_class("EmbeddingModel", class::object())?;
+    let ruby = Ruby::get().unwrap();
+    let rb_embedding_model = rb_candle.define_class("EmbeddingModel", ruby.class_object())?;
     rb_embedding_model.define_singleton_method("_create", function!(EmbeddingModel::new, 5))?;
     // Expose embedding with an optional pooling_method argument (default: "pooled")
     rb_embedding_model.define_method("_embedding", method!(EmbeddingModel::embedding, 2))?;

data/ext/candle/src/ruby/errors.rs

@@ -1,14 +1,16 @@
 use magnus::Error;
 
 pub fn wrap_std_err(err: Box<dyn std::error::Error + Send + Sync>) -> Error {
-    Error::new(magnus::exception::runtime_error(), err.to_string())
+    let ruby = magnus::Ruby::get().unwrap();
+    Error::new(ruby.exception_runtime_error(), err.to_string())
 }
 
 pub fn wrap_candle_err(err: candle_core::Error) -> Error {
-    Error::new(magnus::exception::runtime_error(), err.to_string())
+    let ruby = magnus::Ruby::get().unwrap();
+    Error::new(ruby.exception_runtime_error(), err.to_string())
 }
 
 pub fn wrap_hf_err(err: hf_hub::api::sync::ApiError) -> Error {
-    Error::new(magnus::exception::runtime_error(), err.to_string())
+    let ruby = magnus::Ruby::get().unwrap();
+    Error::new(ruby.exception_runtime_error(), err.to_string())
 }
-