torch-rb 0.23.0 → 0.23.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f09e8876f931e0d2d2ed1620cfac6019b2d3ac9a42e708bc2d2bc5d9e0f84e51
-  data.tar.gz: 55712f92837b23fb952c78c30413203be47d09f736f3641a7a46cd34a6c085df
+  metadata.gz: af0e575eccaa4ab574b53df94fb6b4f4c50cc26cf76d96d6564d97d71c08dbb6
+  data.tar.gz: f54788198cac0ce2a970f92cf965aa426872e3a4b16f36683da2aa5fb1b82580
 SHA512:
-  metadata.gz: d2c140c59a26644f953dc7996b16cf83cee57d3c573e18275169fde76d85528c480ce905e57e97f0dc3d211a1c5987406785eb469ee75a64990482029ad594e2
-  data.tar.gz: 4460ebd50c579464a6272f463421ae1b6783e5123b79e9278477439ab3a4b0a582cad1951288610c19d323bc25ce770c72968e0cbedc509376c0de0778843be5
+  metadata.gz: c14d63c032f08b4d1f2a147a8a12f8337101206f9f78e0ad35e21f01bb960c6f91031bb66d364001ee9dbe1a2eb9b7c91792e81ed4f9bd89a2d07ff6b53fefc6
+  data.tar.gz: 50aeeca2ce811c594c436aa1b55cb72808ea001fc1c78aaf989040491ad942020930b378179bb245bcb7d4c3a32bb9919d9d114f121926b5968cf64461bc210b

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.23.1 (2026-02-19)
+
+- Fixed memory leaks with exceptions
+- Fixed error with Rice 4.11
+
 ## 0.23.0 (2026-01-21)
 
 - Updated LibTorch to 2.10.0

data/README.md

@@ -22,7 +22,7 @@ As well as:
 First, [download LibTorch](https://pytorch.org/get-started/locally/). For Mac arm64, use:
 
 ```sh
-curl -L https://download.pytorch.org/libtorch/cpu/libtorch-macos-arm64-2.9.1.zip > libtorch.zip
+curl -L https://download.pytorch.org/libtorch/cpu/libtorch-macos-arm64-2.10.0.zip > libtorch.zip
 unzip -q libtorch.zip
 ```
 

data/ext/torch/nn.cpp

@@ -1,3 +1,4 @@
+#include <optional>
 #include <utility>
 
 #include <torch/torch.h>
@@ -95,7 +96,7 @@ void init_nn(Rice::Module& m) {
       "grad",
       [](Parameter& self) {
         auto grad = self.grad();
-        return grad.defined() ? Rice::Object(Rice::detail::To_Ruby<torch::Tensor>().convert(grad)) : Rice::Nil;
+        return grad.defined() ? std::optional<torch::Tensor>{grad} : std::nullopt;
       })
     // can't use grad=
     // assignment methods fail with Ruby 3.0

data/ext/torch/ruby_arg_parser.cpp

@@ -120,7 +120,7 @@ bool is_tensor_list(VALUE obj, int argnum, bool throw_error) {
     VALUE iobj = rb_ary_entry(obj, idx);
     if (!THPVariable_Check(iobj)) {
       if (throw_error) {
-        rb_raise(rb_eArgError, "expected Tensor as element %d in argument %d, but got %s",
+        throw Rice::Exception(rb_eArgError, "expected Tensor as element %d in argument %d, but got %s",
             static_cast<int>(idx), argnum, rb_obj_classname(obj));
       }
       return false;
@@ -583,10 +583,10 @@ static void extra_args(const FunctionSignature& signature, ssize_t nargs) {
   const long min_args = signature.min_args;
   const long nargs_ = nargs;
   if (min_args != max_pos_args) {
-    rb_raise(rb_eArgError, "%s() takes from %ld to %ld positional arguments but %ld were given",
+    throw Rice::Exception(rb_eArgError, "%s() takes from %ld to %ld positional arguments but %ld were given",
         signature.name.c_str(), min_args, max_pos_args, nargs_);
   }
-  rb_raise(rb_eArgError, "%s() takes %ld positional argument%s but %ld %s given",
+  throw Rice::Exception(rb_eArgError, "%s() takes %ld positional argument%s but %ld %s given",
       signature.name.c_str(),
       max_pos_args, max_pos_args == 1 ? "" : "s",
       nargs_, nargs == 1 ? "was" : "were");
@@ -608,7 +608,7 @@ static void missing_args(const FunctionSignature& signature, int idx) {
     }
   }
 
-  rb_raise(rb_eArgError, "%s() missing %d required positional argument%s: %s",
+  throw Rice::Exception(rb_eArgError, "%s() missing %d required positional argument%s: %s",
       signature.name.c_str(),
       num_missing,
       num_missing == 1 ? "s" : "",
@@ -636,23 +636,23 @@ static void extra_kwargs(FunctionSignature& signature, VALUE kwargs, ssize_t num
     key = rb_ary_entry(keys, 0);
 
     if (!THPUtils_checkSymbol(key)) {
-      rb_raise(rb_eArgError, "keywords must be symbols, not %s", rb_obj_classname(key));
+      throw Rice::Exception(rb_eArgError, "keywords must be symbols, not %s", rb_obj_classname(key));
     }
 
     auto param_idx = find_param(signature, key);
     if (param_idx < 0) {
-      rb_raise(rb_eArgError, "%s() got an unexpected keyword argument '%s'",
+      throw Rice::Exception(rb_eArgError, "%s() got an unexpected keyword argument '%s'",
           signature.name.c_str(), rb_id2name(rb_to_id(key)));
     }
 
     if (param_idx < num_pos_args) {
-      rb_raise(rb_eArgError, "%s() got multiple values for argument '%s'",
+      throw Rice::Exception(rb_eArgError, "%s() got multiple values for argument '%s'",
           signature.name.c_str(), rb_id2name(rb_to_id(key)));
     }
   }
 
   // this should never be hit
-  rb_raise(rb_eArgError, "invalid keyword arguments");
+  throw Rice::Exception(rb_eArgError, "invalid keyword arguments");
 }
 
 VALUE missing = Qundef;
@@ -740,12 +740,12 @@ bool FunctionSignature::parse(VALUE self, VALUE args, VALUE kwargs, VALUE dst[],
     } else if (raise_exception) {
       if (is_kwd) {
         // foo(): argument 'other' must be str, not int
-        rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, not %s",
+        throw Rice::Exception(rb_eArgError, "%s(): argument '%s' must be %s, not %s",
             name.c_str(), param.name.c_str(), param.type_name().c_str(),
             rb_obj_classname(obj));
       } else {
         // foo(): argument 'other' (position 2) must be str, not int
-        rb_raise(rb_eArgError, "%s(): argument '%s' (position %ld) must be %s, not %s",
+        throw Rice::Exception(rb_eArgError, "%s(): argument '%s' (position %ld) must be %s, not %s",
             name.c_str(), param.name.c_str(), static_cast<long>(arg_pos + 1),
             param.type_name().c_str(), rb_obj_classname(obj));
       }

data/ext/torch/ruby_arg_parser.h

@@ -165,7 +165,7 @@ inline std::array<at::Tensor, N> RubyArgs::tensorlist_n(int i) {
   Check_Type(arg, T_ARRAY);
   auto size = RARRAY_LEN(arg);
   if (size != N) {
-    rb_raise(rb_eArgError, "expected array of %d elements but got %d", N, static_cast<int>(size));
+    throw Rice::Exception(rb_eArgError, "expected array of %d elements but got %d", N, static_cast<int>(size));
   }
   for (int idx = 0; idx < size; idx++) {
     VALUE obj = rb_ary_entry(arg, idx);
@@ -206,7 +206,7 @@ inline std::vector<int64_t> RubyArgs::intlistWithDefault(int i, std::vector<int6
     if (FIXNUM_P(obj)) {
       res[idx] = Rice::detail::From_Ruby<int64_t>().convert(obj);
     } else {
-      rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
+      throw Rice::Exception(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
           signature.name.c_str(), signature.params[i].name.c_str(),
           signature.params[i].type_name().c_str(), rb_obj_classname(obj), idx + 1);
     }
@@ -270,7 +270,7 @@ inline ScalarType RubyArgs::scalartype(int i) {
 
   auto it = dtype_map.find(args[i]);
   if (it == dtype_map.end()) {
-    rb_raise(rb_eArgError, "invalid dtype: %s", rb_id2name(rb_to_id(args[i])));
+    throw Rice::Exception(rb_eArgError, "invalid dtype: %s", rb_id2name(rb_to_id(args[i])));
   }
   return it->second;
 }
@@ -321,7 +321,7 @@ inline c10::OptionalArray<double> RubyArgs::doublelistOptional(int i) {
     if (FIXNUM_P(obj) || RB_FLOAT_TYPE_P(obj)) {
       res[idx] = Rice::detail::From_Ruby<double>().convert(obj);
     } else {
-      rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
+      throw Rice::Exception(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
           signature.name.c_str(), signature.params[i].name.c_str(),
           signature.params[i].type_name().c_str(), rb_obj_classname(obj), idx + 1);
     }
@@ -338,7 +338,7 @@ inline at::Layout RubyArgs::layout(int i) {
 
   auto it = layout_map.find(args[i]);
   if (it == layout_map.end()) {
-    rb_raise(rb_eArgError, "invalid layout: %s", rb_id2name(rb_to_id(args[i])));
+    throw Rice::Exception(rb_eArgError, "invalid layout: %s", rb_id2name(rb_to_id(args[i])));
   }
   return it->second;
 }
@@ -469,7 +469,7 @@ struct RubyArgParser {
     template<int N>
     inline RubyArgs parse(VALUE self, int argc, VALUE* argv, ParsedArgs<N> &dst) {
       if (N < max_args) {
-        rb_raise(rb_eArgError, "RubyArgParser: dst ParsedArgs buffer does not have enough capacity, expected %d (got %d)", static_cast<int>(max_args), N);
+        throw Rice::Exception(rb_eArgError, "RubyArgParser: dst ParsedArgs buffer does not have enough capacity, expected %d (got %d)", static_cast<int>(max_args), N);
       }
       return raw_parse(self, argc, argv, dst.args);
     }
@@ -493,7 +493,7 @@ struct RubyArgParser {
       print_error(self, args, kwargs, parsed_args);
 
       // TODO better message
-      rb_raise(rb_eArgError, "No matching signatures");
+      throw Rice::Exception(rb_eArgError, "No matching signatures");
     }
 
     void print_error(VALUE self, VALUE args, VALUE kwargs, VALUE parsed_args[]) {

data/ext/torch/templates.h

@@ -55,7 +55,7 @@ namespace Rice::detail {
     explicit To_Ruby(Arg* arg) : arg_(arg) { }
 
     VALUE convert(c10::complex<T> const& x) {
-      return rb_dbl_complex_new(x.real(), x.imag());
+      return protect(rb_dbl_complex_new, x.real(), x.imag());
     }
 
   private:
@@ -72,8 +72,8 @@ namespace Rice::detail {
     double is_convertible(VALUE value) { return Convertible::Exact; }
 
     c10::complex<T> convert(VALUE x) {
-      VALUE real = rb_funcall(x, rb_intern("real"), 0);
-      VALUE imag = rb_funcall(x, rb_intern("imag"), 0);
+      VALUE real = protect(rb_funcall, x, rb_intern("real"), 0);
+      VALUE imag = protect(rb_funcall, x, rb_intern("imag"), 0);
       return c10::complex<T>(From_Ruby<T>().convert(real), From_Ruby<T>().convert(imag));
     }
 

data/ext/torch/tensor.cpp

@@ -1,3 +1,4 @@
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -28,15 +29,15 @@ Array flat_data(Tensor& tensor) {
 Rice::Class rb_cTensor;
 
 std::vector<TensorIndex> index_vector(Array a) {
-  Object obj;
-
   std::vector<TensorIndex> indices;
   indices.reserve(a.size());
 
   for (long i = 0; i < a.size(); i++) {
-    obj = a[i];
+    Object obj(a[i]);
 
-    if (obj.is_instance_of(rb_cInteger)) {
+    if (obj.is_nil()) {
+      indices.push_back(torch::indexing::None);
+    } else if (obj.is_instance_of(rb_cInteger)) {
       indices.push_back(Rice::detail::From_Ruby<int64_t>().convert(obj.value()));
     } else if (obj.is_instance_of(rb_cRange)) {
       torch::optional<c10::SymInt> start_index = torch::nullopt;
@@ -64,12 +65,10 @@ std::vector<TensorIndex> index_vector(Array a) {
       indices.push_back(torch::indexing::Slice(start_index, stop_index));
     } else if (obj.is_instance_of(rb_cTensor)) {
       indices.push_back(Rice::detail::From_Ruby<Tensor>().convert(obj.value()));
-    } else if (obj.is_nil()) {
-      indices.push_back(torch::indexing::None);
-    } else if (obj == Rice::True || obj == Rice::False) {
+    } else if (obj.value() == Qtrue || obj.value() == Qfalse) {
       indices.push_back(Rice::detail::From_Ruby<bool>().convert(obj.value()));
     } else {
-      throw Rice::Exception(rb_eArgError, "Unsupported index type: %s", rb_obj_classname(obj));
+      throw Rice::Exception(rb_eArgError, "Unsupported index type: %s", rb_obj_classname(obj.value()));
     }
   }
   return indices;
@@ -102,7 +101,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
   add_tensor_functions(rb_cTensor);
   THPVariableClass = rb_cTensor.value();
 
-  rb_define_method(rb_cTensor, "backward", (VALUE (*)(...)) tensor__backward, -1);
+  rb_define_method(rb_cTensor, "backward", tensor__backward, -1);
 
   rb_cTensor
     .define_method("cuda?", [](Tensor& self) { return self.is_cuda(); })
@@ -168,7 +167,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
       "grad",
       [](Tensor& self) {
         auto grad = self.grad();
-        return grad.defined() ? Object(Rice::detail::To_Ruby<torch::Tensor>().convert(grad)) : Rice::Nil;
+        return grad.defined() ? std::optional<torch::Tensor>{grad} : std::nullopt;
       })
     // can't use grad=
     // assignment methods fail with Ruby 3.0
@@ -184,15 +183,15 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
 
         // TODO support sparse grad
         if (!grad.options().type_equal(self.options())) {
-          rb_raise(rb_eArgError, "assigned grad has data of a different type");
+          throw Rice::Exception(rb_eArgError, "assigned grad has data of a different type");
         }
 
         if (self.is_cuda() && grad.get_device() != self.get_device()) {
-          rb_raise(rb_eArgError, "assigned grad has data located on a different device");
+          throw Rice::Exception(rb_eArgError, "assigned grad has data located on a different device");
         }
 
         if (!self.sizes().equals(grad.sizes())) {
-          rb_raise(rb_eArgError, "assigned grad has data of a different size");
+          throw Rice::Exception(rb_eArgError, "assigned grad has data of a different size");
         }
 
         self.mutable_grad() = grad;

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.23.0"
+  VERSION = "0.23.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.23.1
 platform: ruby
 authors:
 - Andrew Kane