red-candle 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3678037fbb196c621c8e9df6a213b0d3dffbdb1b8b3dfd73eee4a7ea2feafca
-  data.tar.gz: ada97ef81af854439622bdc12b796442be9e0f31e7c7d8a5df374c7bfb07ff2e
+  metadata.gz: cd566594df4f0d3ec8ecd592b1d71610ef0ba2091cd91ea53549405a8c5c9b18
+  data.tar.gz: cfaab403935e927371fbd2f605ea60da3f44effd64950bb132651a5e6437e30c
 SHA512:
-  metadata.gz: d353177318c4599fa30974a676350087a8e5fd070fe3d317344a4e1b3ae022cb69adf742d62063c2da09dbab7e971cbfae1e53a87527ce7f1c18afd1223797e8
-  data.tar.gz: df4b2f43f6fb1aa623053fd09d6e48eba0d8c2615f51dc2accdc4dc292fb3fb7d665553b04cae3747e001e04cd4b9cdbe5c022c3efd077daddf97e074a1e9e5c
+  metadata.gz: b18f384766db5a3de2f794764a8a47d3d69261ae4bf5c93992df7228fe9a5817eb1862b516a9ee3e63b5d349936f46534d50f1378b7932c7ac482550270a8bea
+  data.tar.gz: ce74834cde884bf03e3d163f6d081e87f95db0fba8db24300b8c6aa5b0f1f0162542c836bebb414010534778e394ca36faaec807ff1cc652902c3b318503def5

data/README.md

@@ -888,6 +888,69 @@ bundle exec rake compile
 
 Pull requests are welcome.
 
+## Testing
+
+Red Candle has comprehensive tests at both the Ruby and Rust levels:
+
+### Ruby Tests
+```bash
+# Run all Ruby tests
+bundle exec rake test
+
+# Run specific test suites
+bundle exec rake test:device         # Device compatibility tests
+bundle exec rake test:benchmark      # Benchmark tests
+bundle exec rake test:llm:mistral    # Model-specific tests
+```
+
+### Rust Tests
+```bash
+# Run Rust unit and integration tests
+cd ext/candle && cargo test
+
+# Or use the Rake task
+bundle exec rake rust:test
+```
+
+The Rust tests include:
+- Unit tests within source files (using `#[cfg(test)]` modules)
+- Integration tests for external dependencies (candle_core operations)
+- Tests for structured generation, tokenization, and text generation
+
+### Code Coverage
+
+#### Rust Code Coverage
+Red Candle uses `cargo-llvm-cov` for Rust code coverage analysis:
+
+```bash
+# Generate HTML coverage report (opens in target/llvm-cov/html/index.html)
+bundle exec rake rust:coverage:html
+
+# Show coverage summary in terminal
+bundle exec rake rust:coverage:summary
+
+# Generate detailed coverage report
+bundle exec rake rust:coverage:report
+
+# Generate LCOV format for CI integration
+bundle exec rake rust:coverage:lcov
+
+# Clean coverage data
+bundle exec rake rust:coverage:clean
+```
+
+**Note**: Overall Rust coverage shows ~17% because most code consists of Ruby FFI bindings that are tested through Ruby tests. The testable Rust components have high coverage:
+- Constrained generation: 99.59%
+- Schema processing: 90.99%
+- Integration tests: 97.12%
+
+#### Ruby Code Coverage
+Ruby test coverage is generated automatically when running tests:
+```bash
+bundle exec rake test
+# Coverage report generated in coverage/index.html
+```
+
 ## Release
 
 1. Update version number in `lib/candle/version.rb` and commit.

data/Rakefile

@@ -134,3 +134,43 @@ namespace :doc do
 end
 
 task doc: "doc:default"
+
+namespace :rust do
+  desc "Run Rust tests with code coverage"
+  namespace :coverage do
+    desc "Generate HTML coverage report"
+    task :html do
+      sh "cd ext/candle && cargo llvm-cov --html"
+      puts "Coverage report generated in target/llvm-cov/html/index.html"
+    end
+
+    desc "Generate coverage report in terminal"
+    task :report do
+      sh "cd ext/candle && cargo llvm-cov"
+    end
+
+    desc "Show coverage summary"
+    task :summary do
+      sh "cd ext/candle && cargo llvm-cov --summary-only"
+    end
+
+    desc "Generate lcov format coverage report"
+    task :lcov do
+      sh "cd ext/candle && cargo llvm-cov --lcov --output-path ../../coverage/lcov.info"
+      puts "LCOV report generated in coverage/lcov.info"
+    end
+
+    desc "Clean coverage data"
+    task :clean do
+      sh "cd ext/candle && cargo llvm-cov clean"
+    end
+  end
+
+  desc "Run Rust tests"
+  task :test do
+    sh "cd ext/candle && cargo test"
+  end
+end
+
+desc "Run Rust tests with coverage (alias)"
+task "coverage:rust" => "rust:coverage:html"

data/ext/candle/src/llm/quantized_gguf.rs

@@ -320,7 +320,9 @@ impl QuantizedGGUF {
         // Check model name since Mistral GGUF reports as llama architecture
         let model_lower = self.model_id.to_lowercase();
         
-        if model_lower.contains("mistral") {
+        if model_lower.contains("tinyllama") {
+            self.apply_chatml_template(messages)
+        } else if model_lower.contains("mistral") {
             self.apply_mistral_template(messages)
         } else if model_lower.contains("gemma") {
             // Always use Gemma template for Gemma models, regardless of loader used
@@ -516,6 +518,20 @@ impl QuantizedGGUF {
         Ok(prompt)
     }
     
+    fn apply_chatml_template(&self, messages: &[serde_json::Value]) -> CandleResult<String> {
+        let mut prompt = String::new();
+        
+        for message in messages {
+            let role = message["role"].as_str().unwrap_or("");
+            let content = message["content"].as_str().unwrap_or("");
+            
+            prompt.push_str(&format!("<|{}|>\n{}</s>\n", role, content));
+        }
+        
+        prompt.push_str("<|assistant|>");
+        Ok(prompt)
+    }
+    
     fn apply_generic_template(&self, messages: &[serde_json::Value]) -> String {
         let mut prompt = String::new();
         

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

@@ -199,4 +199,5 @@ pub fn init(rb_candle: RModule) -> Result<()> {
     rb_device.define_method("inspect", method!(Device::__repr__, 0))?;
     rb_device.define_method("==", method!(Device::__eq__, 1))?;
     Ok(())
-}
+}
+

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

@@ -35,3 +35,4 @@ pub fn init(rb_candle: RModule) -> Result<()> {
     rb_dtype.define_method("inspect", method!(DType::__repr__, 0))?;
     Ok(())
 }
+

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

@@ -11,3 +11,4 @@ pub fn wrap_candle_err(err: candle_core::Error) -> Error {
 pub fn wrap_hf_err(err: hf_hub::api::sync::ApiError) -> Error {
     Error::new(magnus::exception::runtime_error(), err.to_string())
 }
+

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

@@ -651,4 +651,5 @@ pub fn init(rb_candle: RModule) -> Result<()> {
     rb_tensor.define_method("to_s", method!(Tensor::__str__, 0))?;
     rb_tensor.define_method("inspect", method!(Tensor::__repr__, 0))?;
     Ok(())
-}
+}
+

data/ext/candle/src/tokenizer/mod.rs

@@ -100,4 +100,5 @@ impl TokenizerWrapper {
     pub fn inner_mut(&mut self) -> &mut Tokenizer {
         &mut self.tokenizer
     }
-}
+}
+

data/ext/candle/tests/device_tests.rs

@@ -0,0 +1,43 @@
+use candle_core::Device as CoreDevice;
+
+#[test]
+fn test_device_creation() {
+    // CPU device should always work
+    let cpu = CoreDevice::Cpu;
+    assert!(matches!(cpu, CoreDevice::Cpu));
+    
+    // Test device display
+    assert_eq!(format!("{:?}", cpu), "Cpu");
+}
+
+#[cfg(feature = "cuda")]
+#[test]
+#[ignore = "requires CUDA hardware"]
+fn test_cuda_device_creation() {
+    // This might fail if no CUDA device is available
+    match CoreDevice::new_cuda(0) {
+        Ok(device) => assert!(matches!(device, CoreDevice::Cuda(_))),
+        Err(_) => println!("No CUDA device available for testing"),
+    }
+}
+
+#[cfg(feature = "metal")] 
+#[test]
+#[ignore = "requires Metal hardware"]
+fn test_metal_device_creation() {
+    // This might fail if no Metal device is available
+    match CoreDevice::new_metal(0) {
+        Ok(device) => assert!(matches!(device, CoreDevice::Metal(_))),
+        Err(_) => println!("No Metal device available for testing"),
+    }
+}
+
+#[test]
+fn test_device_matching() {
+    let cpu1 = CoreDevice::Cpu;
+    let cpu2 = CoreDevice::Cpu;
+    
+    // Same device types should match
+    assert!(matches!(cpu1, CoreDevice::Cpu));
+    assert!(matches!(cpu2, CoreDevice::Cpu));
+}

data/ext/candle/tests/tensor_tests.rs

@@ -0,0 +1,162 @@
+use candle_core::{Tensor, Device, DType};
+
+#[test]
+fn test_tensor_creation() {
+    let device = Device::Cpu;
+    
+    // Test tensor creation from slice
+    let data = vec![1.0f32, 2.0, 3.0, 4.0];
+    let tensor = Tensor::new(&data[..], &device).unwrap();
+    assert_eq!(tensor.dims(), &[4]);
+    assert_eq!(tensor.dtype(), DType::F32);
+    
+    // Test zeros
+    let zeros = Tensor::zeros(&[2, 3], DType::F32, &device).unwrap();
+    assert_eq!(zeros.dims(), &[2, 3]);
+    
+    // Test ones
+    let ones = Tensor::ones(&[3, 2], DType::F32, &device).unwrap();
+    assert_eq!(ones.dims(), &[3, 2]);
+}
+
+#[test]
+fn test_tensor_arithmetic() {
+    let device = Device::Cpu;
+    
+    let a = Tensor::new(&[1.0f32, 2.0, 3.0], &device).unwrap();
+    let b = Tensor::new(&[4.0f32, 5.0, 6.0], &device).unwrap();
+    
+    // Addition
+    let sum = a.add(&b).unwrap();
+    let sum_vec: Vec<f32> = sum.to_vec1().unwrap();
+    assert_eq!(sum_vec, vec![5.0, 7.0, 9.0]);
+    
+    // Subtraction
+    let diff = a.sub(&b).unwrap();
+    let diff_vec: Vec<f32> = diff.to_vec1().unwrap();
+    assert_eq!(diff_vec, vec![-3.0, -3.0, -3.0]);
+    
+    // Multiplication
+    let prod = a.mul(&b).unwrap();
+    let prod_vec: Vec<f32> = prod.to_vec1().unwrap();
+    assert_eq!(prod_vec, vec![4.0, 10.0, 18.0]);
+}
+
+#[test]
+fn test_tensor_reshape() {
+    let device = Device::Cpu;
+    
+    let tensor = Tensor::new(&[1.0f32, 2.0, 3.0, 4.0, 5.0, 6.0], &device).unwrap();
+    
+    // Reshape to 2x3
+    let reshaped = tensor.reshape(&[2, 3]).unwrap();
+    assert_eq!(reshaped.dims(), &[2, 3]);
+    
+    // Reshape to 3x2
+    let reshaped = tensor.reshape(&[3, 2]).unwrap();
+    assert_eq!(reshaped.dims(), &[3, 2]);
+}
+
+#[test]
+fn test_tensor_transpose() {
+    let device = Device::Cpu;
+    
+    let tensor = Tensor::new(&[1.0f32, 2.0, 3.0, 4.0], &device)
+        .unwrap()
+        .reshape(&[2, 2])
+        .unwrap();
+    
+    let transposed = tensor.transpose(0, 1).unwrap();
+    assert_eq!(transposed.dims(), &[2, 2]);
+    
+    let values: Vec<f32> = transposed.flatten_all().unwrap().to_vec1().unwrap();
+    assert_eq!(values, vec![1.0, 3.0, 2.0, 4.0]);
+}
+
+#[test]
+fn test_tensor_reduction() {
+    let device = Device::Cpu;
+    
+    let tensor = Tensor::new(&[1.0f32, 2.0, 3.0, 4.0], &device).unwrap();
+    
+    // Sum
+    let sum = tensor.sum_all().unwrap();
+    let sum_val: f32 = sum.to_scalar().unwrap();
+    assert_eq!(sum_val, 10.0);
+    
+    // Mean
+    let mean = tensor.mean_all().unwrap();
+    let mean_val: f32 = mean.to_scalar().unwrap();
+    assert_eq!(mean_val, 2.5);
+}
+
+#[test]
+fn test_tensor_indexing() {
+    let device = Device::Cpu;
+    
+    let tensor = Tensor::new(&[10.0f32, 20.0, 30.0, 40.0], &device).unwrap();
+    
+    // Get element at index 0
+    let elem = tensor.get(0).unwrap();
+    let val: f32 = elem.to_scalar().unwrap();
+    assert_eq!(val, 10.0);
+    
+    // Get element at index 2
+    let elem = tensor.get(2).unwrap();
+    let val: f32 = elem.to_scalar().unwrap();
+    assert_eq!(val, 30.0);
+}
+
+#[test]
+fn test_tensor_matmul() {
+    let device = Device::Cpu;
+    
+    // 2x3 matrix
+    let a = Tensor::new(&[1.0f32, 2.0, 3.0, 4.0, 5.0, 6.0], &device)
+        .unwrap()
+        .reshape(&[2, 3])
+        .unwrap();
+    
+    // 3x2 matrix
+    let b = Tensor::new(&[7.0f32, 8.0, 9.0, 10.0, 11.0, 12.0], &device)
+        .unwrap()
+        .reshape(&[3, 2])
+        .unwrap();
+    
+    // Matrix multiplication
+    let result = a.matmul(&b).unwrap();
+    assert_eq!(result.dims(), &[2, 2]);
+    
+    let values: Vec<f32> = result.flatten_all().unwrap().to_vec1().unwrap();
+    // [1*7 + 2*9 + 3*11, 1*8 + 2*10 + 3*12, 4*7 + 5*9 + 6*11, 4*8 + 5*10 + 6*12]
+    // = [58, 64, 139, 154]
+    assert_eq!(values, vec![58.0, 64.0, 139.0, 154.0]);
+}
+
+#[test]
+fn test_tensor_where() {
+    let device = Device::Cpu;
+    
+    // Create a condition tensor where values > 0 are treated as true
+    let cond_values = Tensor::new(&[1.0f32, 0.0, 1.0], &device).unwrap();
+    let cond = cond_values.gt(&Tensor::zeros(cond_values.shape(), DType::F32, &device).unwrap()).unwrap();
+    
+    let on_true = Tensor::new(&[10.0f32, 20.0, 30.0], &device).unwrap();
+    let on_false = Tensor::new(&[100.0f32, 200.0, 300.0], &device).unwrap();
+    
+    let result = cond.where_cond(&on_true, &on_false).unwrap();
+    let values: Vec<f32> = result.to_vec1().unwrap();
+    assert_eq!(values, vec![10.0, 200.0, 30.0]);
+}
+
+#[test]
+fn test_tensor_narrow() {
+    let device = Device::Cpu;
+    
+    let tensor = Tensor::new(&[1.0f32, 2.0, 3.0, 4.0, 5.0], &device).unwrap();
+    
+    // Narrow from index 1, length 3
+    let narrowed = tensor.narrow(0, 1, 3).unwrap();
+    let values: Vec<f32> = narrowed.to_vec1().unwrap();
+    assert_eq!(values, vec![2.0, 3.0, 4.0]);
+}

data/lib/candle/version.rb

@@ -1,5 +1,5 @@
 # :nocov:
 module Candle
-  VERSION = "1.1.1"
+  VERSION = "1.1.2"
 end
 # :nocov:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: red-candle
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Christopher Petersen
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-28 00:00:00.000000000 Z
+date: 2025-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -196,6 +196,8 @@ files:
 - ext/candle/target/release/build/clang-sys-cac31d63c4694603/out/macros.rs
 - ext/candle/target/release/build/pulp-1b95cfe377eede97/out/x86_64_asm.rs
 - ext/candle/target/release/build/rb-sys-f8ac4edc30ab3e53/out/bindings-0.9.116-mri-arm64-darwin24-3.3.0.rs
+- ext/candle/tests/device_tests.rs
+- ext/candle/tests/tensor_tests.rs
 - lib/candle.rb
 - lib/candle/build_info.rb
 - lib/candle/device_utils.rb