torch-rb 0.23.1 → 0.24.0

data/ext/torch/ivalue.cpp

@@ -53,7 +53,7 @@ void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue) {
       [](torch::IValue& self) {
         auto list = self.toListRef();
         Rice::Array obj;
-        for (auto& elem : list) {
+        for (const auto& elem : list) {
           auto v = torch::IValue{elem};
           obj.push(Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(v)), false);
         }
@@ -74,7 +74,7 @@ void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue) {
       [](torch::IValue& self) {
         auto dict = self.toGenericDict();
         Rice::Hash obj;
-        for (auto& pair : dict) {
+        for (const auto& pair : dict) {
           auto k = torch::IValue{pair.key()};
           auto v = torch::IValue{pair.value()};
           obj[Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(k))] = Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(v));
@@ -91,7 +91,7 @@ void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue) {
       "from_list",
       [](Rice::Array obj) {
         c10::impl::GenericList list(c10::AnyType::get());
-        for (auto entry : obj) {
+        for (const auto& entry : obj) {
           list.push_back(Rice::detail::From_Ruby<torch::IValue>().convert(entry.value()));
         }
         return torch::IValue(list);
@@ -125,7 +125,7 @@ void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue) {
         auto value_type = c10::AnyType::get();
         c10::impl::GenericDict elems(key_type, value_type);
         elems.reserve(obj.size());
-        for (auto entry : obj) {
+        for (const auto& entry : obj) {
           elems.insert(Rice::detail::From_Ruby<torch::IValue>().convert(entry.first), Rice::detail::From_Ruby<torch::IValue>().convert((Rice::Object) entry.second));
         }
         return torch::IValue(std::move(elems));

data/ext/torch/ruby_arg_parser.cpp

@@ -117,11 +117,11 @@ bool is_tensor_list(VALUE obj, int argnum, bool throw_error) {
   }
   auto size = RARRAY_LEN(obj);
   for (int idx = 0; idx < size; idx++) {
-    VALUE iobj = rb_ary_entry(obj, idx);
+    VALUE iobj = Rice::detail::protect(rb_ary_entry, obj, idx);
     if (!THPVariable_Check(iobj)) {
       if (throw_error) {
         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));
+            static_cast<int>(idx), argnum, Rice::detail::protect(rb_obj_classname, obj));
       }
       return false;
     }
@@ -136,7 +136,7 @@ static bool is_int_list(VALUE obj, int broadcast_size) {
       return true;
     }
 
-    auto item = rb_ary_entry(obj, 0);
+    auto item = Rice::detail::protect(rb_ary_entry, obj, 0);
     bool int_first = false;
     if (THPUtils_checkIndex(item)) {
       // we still have to check that the rest of items are NOT symint nodes
@@ -178,7 +178,7 @@ static bool is_int_or_symint_list(VALUE obj, int broadcast_size) {
     if (RARRAY_LEN(obj) == 0) {
       return true;
     }
-    auto item = rb_ary_entry(obj, 0);
+    auto item = Rice::detail::protect(rb_ary_entry, obj, 0);
 
     if (is_int_or_symint(item)) {
       return true;
@@ -631,23 +631,23 @@ static ssize_t find_param(FunctionSignature& signature, VALUE name) {
 static void extra_kwargs(FunctionSignature& signature, VALUE kwargs, ssize_t num_pos_args) {
   VALUE key;
 
-  VALUE keys = rb_funcall(kwargs, rb_intern("keys"), 0);
+  VALUE keys = Rice::detail::protect(rb_funcall, kwargs, rb_intern("keys"), 0);
   if (RARRAY_LEN(keys) > 0) {
-    key = rb_ary_entry(keys, 0);
+    key = Rice::detail::protect(rb_ary_entry, keys, 0);
 
     if (!THPUtils_checkSymbol(key)) {
-      throw Rice::Exception(rb_eArgError, "keywords must be symbols, not %s", rb_obj_classname(key));
+      throw Rice::Exception(rb_eArgError, "keywords must be symbols, not %s", Rice::detail::protect(rb_obj_classname, key));
     }
 
     auto param_idx = find_param(signature, key);
     if (param_idx < 0) {
       throw Rice::Exception(rb_eArgError, "%s() got an unexpected keyword argument '%s'",
-          signature.name.c_str(), rb_id2name(rb_to_id(key)));
+          signature.name.c_str(), Rice::detail::protect(rb_id2name, Rice::detail::protect(rb_to_id, key)));
     }
 
     if (param_idx < num_pos_args) {
       throw Rice::Exception(rb_eArgError, "%s() got multiple values for argument '%s'",
-          signature.name.c_str(), rb_id2name(rb_to_id(key)));
+          signature.name.c_str(), Rice::detail::protect(rb_id2name, Rice::detail::protect(rb_to_id, key)));
     }
   }
 
@@ -703,14 +703,14 @@ bool FunctionSignature::parse(VALUE self, VALUE args, VALUE kwargs, VALUE dst[],
         }
         return false;
       }
-      obj = rb_ary_entry(args, arg_pos);
+      obj = Rice::detail::protect(rb_ary_entry, args, arg_pos);
     } else if (!NIL_P(kwargs)) {
-      obj = rb_hash_lookup2(kwargs, param.ruby_name, missing);
+      obj = Rice::detail::protect(rb_hash_lookup2, kwargs, param.ruby_name, missing);
       // for (VALUE numpy_name: param.numpy_python_names) {
       //   if (obj) {
       //     break;
       //   }
-      //   obj = rb_hash_aref(kwargs, numpy_name);
+      //   obj = Rice::detail::protect(rb_hash_aref, kwargs, numpy_name);
       // }
       is_kwd = true;
     }
@@ -742,12 +742,12 @@ bool FunctionSignature::parse(VALUE self, VALUE args, VALUE kwargs, VALUE dst[],
         // foo(): argument 'other' must be str, not int
         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));
+            Rice::detail::protect(rb_obj_classname, obj));
       } else {
         // foo(): argument 'other' (position 2) must be str, not int
         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));
+            param.type_name().c_str(), Rice::detail::protect(rb_obj_classname, obj));
       }
     } else {
       return false;

data/ext/torch/ruby_arg_parser.h

@@ -168,7 +168,7 @@ inline std::array<at::Tensor, N> RubyArgs::tensorlist_n(int i) {
     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);
+    VALUE obj = Rice::detail::protect(rb_ary_entry, arg, idx);
     res[idx] = Rice::detail::From_Ruby<Tensor>().convert(obj);
   }
   return res;
@@ -202,13 +202,13 @@ inline std::vector<int64_t> RubyArgs::intlistWithDefault(int i, std::vector<int6
   size = RARRAY_LEN(arg);
   std::vector<int64_t> res(size);
   for (idx = 0; idx < size; idx++) {
-    VALUE obj = rb_ary_entry(arg, idx);
+    VALUE obj = Rice::detail::protect(rb_ary_entry, arg, idx);
     if (FIXNUM_P(obj)) {
       res[idx] = Rice::detail::From_Ruby<int64_t>().convert(obj);
     } else {
       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);
+          signature.params[i].type_name().c_str(), Rice::detail::protect(rb_obj_classname, obj), idx + 1);
     }
   }
   return res;
@@ -270,7 +270,7 @@ inline ScalarType RubyArgs::scalartype(int i) {
 
   auto it = dtype_map.find(args[i]);
   if (it == dtype_map.end()) {
-    throw Rice::Exception(rb_eArgError, "invalid dtype: %s", rb_id2name(rb_to_id(args[i])));
+    throw Rice::Exception(rb_eArgError, "invalid dtype: %s", Rice::detail::protect(rb_id2name, Rice::detail::protect(rb_to_id, args[i])));
   }
   return it->second;
 }
@@ -317,13 +317,13 @@ inline c10::OptionalArray<double> RubyArgs::doublelistOptional(int i) {
   auto size = RARRAY_LEN(arg);
   std::vector<double> res(size);
   for (idx = 0; idx < size; idx++) {
-    VALUE obj = rb_ary_entry(arg, idx);
+    VALUE obj = Rice::detail::protect(rb_ary_entry, arg, idx);
     if (FIXNUM_P(obj) || RB_FLOAT_TYPE_P(obj)) {
       res[idx] = Rice::detail::From_Ruby<double>().convert(obj);
     } else {
       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);
+          signature.params[i].type_name().c_str(), Rice::detail::protect(rb_obj_classname, obj), idx + 1);
     }
   }
   return res;
@@ -338,7 +338,7 @@ inline at::Layout RubyArgs::layout(int i) {
 
   auto it = layout_map.find(args[i]);
   if (it == layout_map.end()) {
-    throw Rice::Exception(rb_eArgError, "invalid layout: %s", rb_id2name(rb_to_id(args[i])));
+    throw Rice::Exception(rb_eArgError, "invalid layout: %s", Rice::detail::protect(rb_id2name, Rice::detail::protect(rb_to_id, args[i])));
   }
   return it->second;
 }
@@ -358,7 +358,7 @@ inline at::Device RubyArgs::device(int i) {
     return at::Device("cpu");
   }
   if (RB_TYPE_P(args[i], T_STRING)) {
-    const std::string &device_str = THPUtils_unpackString(args[i]);
+    const std::string& device_str = THPUtils_unpackString(args[i]);
     return at::Device(device_str);
   }
   return Rice::detail::From_Ruby<at::Device>().convert(args[i]);
@@ -461,13 +461,13 @@ struct RubyArgParser {
 
       // Check deprecated signatures last
       std::stable_partition(signatures_.begin(), signatures_.end(),
-        [](const FunctionSignature & sig) {
+        [](const FunctionSignature& sig) {
           return !sig.deprecated;
         });
     }
 
     template<int N>
-    inline RubyArgs parse(VALUE self, int argc, VALUE* argv, ParsedArgs<N> &dst) {
+    inline RubyArgs parse(VALUE self, int argc, VALUE* argv, ParsedArgs<N>& dst) {
       if (N < max_args) {
         throw Rice::Exception(rb_eArgError, "RubyArgParser: dst ParsedArgs buffer does not have enough capacity, expected %d (got %d)", static_cast<int>(max_args), N);
       }
@@ -476,7 +476,7 @@ struct RubyArgParser {
 
     inline RubyArgs raw_parse(VALUE self, int argc, VALUE* argv, VALUE parsed_args[]) {
       VALUE args, kwargs;
-      rb_scan_args(argc, argv, "*:", &args, &kwargs);
+      Rice::detail::protect(rb_scan_args, argc, argv, "*:", &args, &kwargs);
 
       if (signatures_.size() == 1) {
         auto& signature = signatures_[0];

data/ext/torch/templates.h

@@ -54,7 +54,7 @@ namespace Rice::detail {
 
     explicit To_Ruby(Arg* arg) : arg_(arg) { }
 
-    VALUE convert(c10::complex<T> const& x) {
+    VALUE convert(const c10::complex<T>& x) {
       return protect(rb_dbl_complex_new, x.real(), x.imag());
     }
 

data/ext/torch/tensor.cpp

@@ -1,5 +1,6 @@
 #include <optional>
 #include <string>
+#include <string_view>
 #include <vector>
 
 #include <torch/torch.h>
@@ -68,7 +69,7 @@ std::vector<TensorIndex> index_vector(Array a) {
     } 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.value()));
+      throw Rice::Exception(rb_eArgError, "Unsupported index type: %s", Rice::detail::protect(rb_obj_classname, obj.value()));
     }
   }
   return indices;
@@ -108,8 +109,6 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
     .define_method("mps?", [](Tensor& self) { return self.is_mps(); })
     .define_method("sparse?", [](Tensor& self) { return self.is_sparse(); })
     .define_method("quantized?", [](Tensor& self) { return self.is_quantized(); })
-    .define_method("dim", [](Tensor& self) { return self.dim(); })
-    .define_method("numel", [](Tensor& self) { return self.numel(); })
     .define_method("element_size", [](Tensor& self) { return self.element_size(); })
     .define_method("requires_grad", [](Tensor& self) { return self.requires_grad(); })
     .define_method(
@@ -127,7 +126,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
       "shape",
       [](Tensor& self) {
         Array a;
-        for (auto &size : self.sizes()) {
+        for (const auto& size : self.sizes()) {
           a.push(size, false);
         }
         return a;
@@ -136,7 +135,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
       "_strides",
       [](Tensor& self) {
         Array a;
-        for (auto &stride : self.strides()) {
+        for (const auto& stride : self.strides()) {
           a.push(stride, false);
         }
         return a;
@@ -153,11 +152,6 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
         auto vec = index_vector(indices);
         return self.index_put_(vec, value);
       })
-    .define_method(
-      "contiguous?",
-      [](Tensor& self) {
-        return self.is_contiguous();
-      })
     .define_method(
       "_requires_grad!",
       [](Tensor& self, bool requires_grad) {
@@ -233,8 +227,8 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
           tensor = tensor.contiguous();
         }
 
-        auto data_ptr = (const char *) tensor.data_ptr();
-        return std::string(data_ptr, tensor.numel() * tensor.element_size());
+        auto data_ptr = static_cast<const char *>(tensor.data_ptr());
+        return Rice::String(std::string_view(data_ptr, tensor.numel() * tensor.element_size()));
       })
     // for TorchVision
     .define_method(

data/ext/torch/torch.cpp

@@ -12,7 +12,7 @@
 #include "utils.h"
 
 template<typename T>
-torch::Tensor make_tensor(Rice::Array a, const std::vector<int64_t> &size, const torch::TensorOptions &options) {
+torch::Tensor make_tensor(Rice::Array a, const std::vector<int64_t>& size, const torch::TensorOptions& options) {
   std::vector<T> vec;
   vec.reserve(a.size());
   for (long i = 0; i < a.size(); i++) {
@@ -61,13 +61,13 @@ void init_torch(Rice::Module& m) {
     // begin operations
     .define_singleton_function(
       "_save",
-      [](const torch::IValue &value) {
+      [](const torch::IValue& value) {
         auto v = torch::pickle_save(value);
-        return Rice::Object(rb_str_new(v.data(), v.size()));
+        return Rice::Object(Rice::detail::protect(rb_str_new, v.data(), v.size()));
       })
     .define_singleton_function(
       "_load",
-      [](const std::string &filename) {
+      [](const std::string& filename) {
         // https://github.com/pytorch/pytorch/issues/20356#issuecomment-567663701
         std::ifstream input(filename, std::ios::binary);
         std::vector<char> bytes(
@@ -78,13 +78,13 @@ void init_torch(Rice::Module& m) {
       })
     .define_singleton_function(
       "_from_blob",
-      [](Rice::String s, const std::vector<int64_t> &size, const torch::TensorOptions &options) {
+      [](Rice::String s, const std::vector<int64_t>& size, const torch::TensorOptions& options) {
         void *data = const_cast<char *>(s.c_str());
         return torch::from_blob(data, size, options);
       })
     .define_singleton_function(
       "_tensor",
-      [](Rice::Array a, const std::vector<int64_t> &size, const torch::TensorOptions &options) {
+      [](Rice::Array a, const std::vector<int64_t>& size, const torch::TensorOptions& options) {
         auto dtype = options.dtype();
         if (dtype == torch::kByte) {
           return make_tensor<uint8_t>(a, size, options);

data/ext/torch/utils.h

@@ -8,7 +8,7 @@
 #include <rice/stl.hpp>
 
 static_assert(
-  TORCH_VERSION_MAJOR == 2 && TORCH_VERSION_MINOR == 10,
+  TORCH_VERSION_MAJOR == 2 && TORCH_VERSION_MINOR == 12,
   "Incompatible LibTorch version"
 );
 
@@ -50,17 +50,17 @@ inline bool THPUtils_checkScalar(VALUE obj) {
 }
 
 inline bool THPDevice_Check(VALUE obj) {
-  return rb_obj_is_kind_of(obj, THPDeviceClass);
+  return Rice::detail::protect(rb_obj_is_kind_of, obj, THPDeviceClass);
 }
 
 inline bool THPGenerator_Check(VALUE obj) {
-  return rb_obj_is_kind_of(obj, THPGeneratorClass);
+  return Rice::detail::protect(rb_obj_is_kind_of, obj, THPGeneratorClass);
 }
 
 inline bool THPVariable_Check(VALUE obj) {
-  return rb_obj_is_kind_of(obj, THPVariableClass);
+  return Rice::detail::protect(rb_obj_is_kind_of, obj, THPVariableClass);
 }
 
 inline bool THPVariable_CheckExact(VALUE obj) {
-  return rb_obj_is_instance_of(obj, THPVariableClass);
+  return Rice::detail::protect(rb_obj_is_instance_of, obj, THPVariableClass);
 }

data/ext/torch/wrap_outputs.h

@@ -15,32 +15,34 @@ inline VALUE wrap(double x) {
   return Rice::detail::To_Ruby<double>().convert(x);
 }
 
-inline VALUE wrap(torch::Tensor x) {
+inline VALUE wrap(const torch::Tensor& x) {
   return Rice::detail::To_Ruby<torch::Tensor>().convert(x);
 }
 
-inline VALUE wrap(torch::Scalar x) {
+inline VALUE wrap(const torch::Scalar& x) {
   return Rice::detail::To_Ruby<torch::Scalar>().convert(x);
 }
 
-inline VALUE wrap(torch::ScalarType x) {
+inline VALUE wrap(const torch::ScalarType& x) {
   return Rice::detail::To_Ruby<torch::ScalarType>().convert(x);
 }
 
-inline VALUE wrap(torch::QScheme x) {
+inline VALUE wrap(const torch::QScheme& x) {
   return Rice::detail::To_Ruby<torch::QScheme>().convert(x);
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     2,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x))
   );
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor, torch::Tensor>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     3,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
@@ -48,8 +50,9 @@ inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x) {
   );
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     4,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
@@ -58,8 +61,9 @@ inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch:
   );
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     5,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
@@ -69,8 +73,9 @@ inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch:
   );
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     4,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
@@ -79,8 +84,9 @@ inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_
   );
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor, double, int64_t>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     4,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
@@ -89,16 +95,17 @@ inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
   );
 }
 
-inline VALUE wrap(torch::TensorList x) {
-  auto a = rb_ary_new2(x.size());
-  for (auto t : x) {
-    rb_ary_push(a, Rice::detail::To_Ruby<torch::Tensor>().convert(t));
+inline VALUE wrap(const torch::TensorList& x) {
+  auto a = Rice::detail::protect(rb_ary_new2, x.size());
+  for (const auto& t : x) {
+    Rice::detail::protect(rb_ary_push, a, Rice::detail::To_Ruby<torch::Tensor>().convert(t));
   }
   return a;
 }
 
-inline VALUE wrap(std::tuple<double, double> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<double, double>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     2,
     Rice::detail::To_Ruby<double>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<double>().convert(std::get<1>(x))

data/lib/torch/hub.rb

@@ -6,37 +6,17 @@ module Torch
       end
 
       def download_url_to_file(url, dst)
-        uri = URI(url)
-        tmp = nil
-        location = nil
+        require "open-uri"
 
-        puts "Downloading #{url}..."
-        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
-          request = Net::HTTP::Get.new(uri)
-
-          http.request(request) do |response|
-            case response
-            when Net::HTTPRedirection
-              location = response["location"]
-            when Net::HTTPSuccess
-              tmp = "#{Dir.tmpdir}/#{Time.now.to_f}" # TODO better name
-              File.open(tmp, "wb") do |f|
-                response.read_body do |chunk|
-                  f.write(chunk)
-                end
-              end
-            else
-              raise Error, "Bad response"
-            end
-          end
-        end
+        uri = URI.parse(url)
+        raise "Invalid URL" unless uri.is_a?(URI::HTTP) # includes https
 
-        if location
-          download_url_to_file(location, dst)
-        else
-          FileUtils.mv(tmp, dst)
-          nil
+        puts "Downloading #{url}..."
+        uri.open(max_redirects: 10) do |download|
+          # TODO move file when possible
+          IO.copy_stream(download, dst.to_str)
         end
+        nil
       end
 
       def load_state_dict_from_url(url, model_dir: nil)

data/lib/torch/nn/module.rb

@@ -197,7 +197,7 @@ module Torch
         named_buffers.values
       end
 
-      # TODO set recurse: true in 0.18.0
+      # TODO set recurse: true in future
       def named_buffers(prefix: "", recurse: false)
         buffers = {}
         if recurse

data/lib/torch/nn/rnn_base.rb

@@ -161,7 +161,7 @@ module Torch
       private
 
       def _flat_weights
-        @all_weights.flatten.map { |v| instance_variable_get("@#{v}") }.compact
+        @all_weights.flatten.filter_map { |v| instance_variable_get("@#{v}") }
       end
 
       def _get_flat_weights

data/lib/torch/version.rb

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

data/lib/torch.rb

@@ -279,7 +279,7 @@ module Torch
   def self._make_tensor_class(dtype, cuda = false)
     cls = Class.new
     device = cuda ? "cuda" : "cpu"
-    cls.define_singleton_method("new") do |*args|
+    cls.define_singleton_method(:new) do |*args|
       if args.size == 1 && args.first.is_a?(Tensor)
         args.first.send(dtype).to(device)
       elsif args.size == 1 && args.first.is_a?(ByteStorage) && dtype == :uint8
@@ -347,7 +347,7 @@ module Torch
       # from_blob does not own the data, so we need to keep
       # a reference to it for duration of tensor
       # can remove when passing pointer directly
-      tensor.instance_variable_set("@_numo_data", data)
+      tensor.instance_variable_set(:@_numo_data, data)
       tensor
     end
 
@@ -426,11 +426,11 @@ module Torch
       end
 
       if options[:dtype].nil?
-        if data.all? { |v| v.is_a?(Integer) }
+        if data.all?(Integer)
           options[:dtype] = :int64
         elsif data.all? { |v| v == true || v == false }
           options[:dtype] = :bool
-        elsif data.any? { |v| v.is_a?(Complex) }
+        elsif data.any?(Complex)
           options[:dtype] = :complex64
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.23.1
+  version: 0.24.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -234,14 +234,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: Deep learning for Ruby, powered by LibTorch
 test_files: []