red-arrow-pycall 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf65599f0a91aa12e9f93971e981e01b0e83807b
-  data.tar.gz: 8c9c6cd4a9d052560a85f9e03334cfcc97895e35
+  metadata.gz: f44174f03927e0a2c9c00306703c6d371787c1ff
+  data.tar.gz: 112085a608bd1fdc3ac523d73f4bb67eefae9f78
 SHA512:
-  metadata.gz: cefa69198ad06b139bf67c82459335ca2f6774f75e09d3776c404ca8c94a18700a8d1d5f82361a445e10ea0ad90f01cf15a548c0d5453b4d5484911e95059f4d
-  data.tar.gz: a541e339f38555aa5300cf144800e509ceca9be610bbc1fc01cf5f3bb1fb7586b363487e4c7805fdae5dc543be725975a66b1d5c29fe96d29a92283b987c8cac
+  metadata.gz: 535bb8bb7b4bee42750dee53e4417b74f6503bbb8f22d205f8bcb01e1c4dfb5547f5fce0d61cf08a30c2341b781eedcc68b381cbdc83ec625e28a3af9e6e4683
+  data.tar.gz: 2ef2a6bfff37eeccdafb446eb70e666c73bb01e85a3d7ccd7bb60e36bdd23a0a86953a8df0c2c0f54c2a4b403f1cb4965bd86bb9f47062e0d740bf4d82cf27e8

data/doc/text/news.md

@@ -1,5 +1,25 @@
 # News
 
+## 0.0.4 - 2018-03-07
+
+### Improvements
+
+  * Added PyCall 1.1.0 support.
+
+## 0.0.3 - 2017-07-13
+
+### Improvements
+
+  * Supported `sizeof(void *) > sizeof(long)` platform such as Windows
+    x64.
+    [GitHub#1][Patch by Kenta Murata]
+
+  * Added `#to_ruby`.
+
+### Thanks
+
+  * Kenta Murata
+
 ## 0.0.2 - 2017-07-08
 
 ### Fixes

data/ext/arrow-pycall/arrow-pycall.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 Kouhei Sutou <kou@clear-code.com>
+ * Copyright 2017-2018 Kouhei Sutou <kou@clear-code.com>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,87 +20,215 @@
 
 #include <arrow/python/pyarrow.h>
 
-extern "C" void Init_arrow_pycall(void);
+#include <pycall.h>
+
+namespace {
+  inline VALUE to_ruby(PyObject *py_object) {
+    return pycall_pyobject_to_ruby(py_object);
+  }
+
+  inline PyObject *to_python(VALUE rb_object) {
+    return pycall_pyobject_wrapper_get_pyobj_ptr(rb_object);
+  }
+}
 
 static VALUE
-rb_arrow_buffer_to_python_object_pointer(VALUE self)
+rb_arrow_buffer_to_python(VALUE self)
 {
   auto buffer = GARROW_BUFFER(RVAL2GOBJ(self));
   auto arrow_buffer = garrow_buffer_get_raw(buffer);
   auto py_buffer = arrow::py::wrap_buffer(arrow_buffer);
-  return LONG2NUM((long)(py_buffer));
+  return to_ruby(py_buffer);
+}
+
+static VALUE
+rb_pycall_arrow_buffer_to_ruby(VALUE self)
+{
+  auto py_buffer = to_python(self);
+  std::shared_ptr<arrow::Buffer> arrow_buffer;
+  auto status = arrow::py::unwrap_buffer(py_buffer, &arrow_buffer);
+  GError *error = NULL;
+  if (!garrow_error_check(&error, status, "[pyarrow][buffer][to-ruby]"))
+    RG_RAISE_ERROR(error);
+  auto garrow_buffer = garrow_buffer_new_raw(&arrow_buffer);
+  return GOBJ2RVAL(garrow_buffer);
 }
 
 static VALUE
-rb_arrow_data_type_to_python_object_pointer(VALUE self)
+rb_arrow_data_type_to_python(VALUE self)
 {
   auto data_type = GARROW_DATA_TYPE(RVAL2GOBJ(self));
   auto arrow_data_type = garrow_data_type_get_raw(data_type);
   auto py_data_type = arrow::py::wrap_data_type(arrow_data_type);
-  return LONG2NUM((long)(py_data_type));
+  return to_ruby(py_data_type);
 }
 
 static VALUE
-rb_arrow_field_to_python_object_pointer(VALUE self)
+rb_pycall_arrow_data_type_to_ruby(VALUE self)
+{
+  auto py_data_type = to_python(self);
+  std::shared_ptr<arrow::DataType> arrow_data_type;
+  auto status = arrow::py::unwrap_data_type(py_data_type, &arrow_data_type);
+  GError *error = NULL;
+  if (!garrow_error_check(&error, status, "[pyarrow][data-type][to-ruby]"))
+    RG_RAISE_ERROR(error);
+  auto garrow_data_type = garrow_data_type_new_raw(&arrow_data_type);
+  return GOBJ2RVAL(garrow_data_type);
+}
+
+static VALUE
+rb_arrow_field_to_python(VALUE self)
 {
   auto field = GARROW_FIELD(RVAL2GOBJ(self));
   auto arrow_field = garrow_field_get_raw(field);
   auto py_field = arrow::py::wrap_field(arrow_field);
-  return LONG2NUM((long)(py_field));
+  return to_ruby(py_field);
+}
+
+static VALUE
+rb_pycall_arrow_field_to_ruby(VALUE self)
+{
+  auto py_field = to_python(self);
+  std::shared_ptr<arrow::Field> arrow_field;
+  auto status = arrow::py::unwrap_field(py_field, &arrow_field);
+  GError *error = NULL;
+  if (!garrow_error_check(&error, status, "[pyarrow][field][to-ruby]"))
+    RG_RAISE_ERROR(error);
+  auto garrow_field = garrow_field_new_raw(&arrow_field);
+  return GOBJ2RVAL(garrow_field);
 }
 
 static VALUE
-rb_arrow_schema_to_python_object_pointer(VALUE self)
+rb_arrow_schema_to_python(VALUE self)
 {
   auto schema = GARROW_SCHEMA(RVAL2GOBJ(self));
   auto arrow_schema = garrow_schema_get_raw(schema);
   auto py_schema = arrow::py::wrap_schema(arrow_schema);
-  return LONG2NUM((long)(py_schema));
+  return to_ruby(py_schema);
 }
 
 static VALUE
-rb_arrow_array_to_python_object_pointer(VALUE self)
+rb_pycall_arrow_schema_to_ruby(VALUE self)
+{
+  auto py_schema = to_python(self);
+  std::shared_ptr<arrow::Schema> arrow_schema;
+  auto status = arrow::py::unwrap_schema(py_schema, &arrow_schema);
+  GError *error = NULL;
+  if (!garrow_error_check(&error, status, "[pyarrow][schema][to-ruby]"))
+    RG_RAISE_ERROR(error);
+  auto garrow_schema = garrow_schema_new_raw(&arrow_schema);
+  return GOBJ2RVAL(garrow_schema);
+}
+
+static VALUE
+rb_arrow_array_to_python(VALUE self)
 {
   auto array = GARROW_ARRAY(RVAL2GOBJ(self));
   auto arrow_array = garrow_array_get_raw(array);
   auto py_array = arrow::py::wrap_array(arrow_array);
-  return LONG2NUM((long)(py_array));
+  return to_ruby(py_array);
 }
 
 static VALUE
-rb_arrow_tensor_to_python_object_pointer(VALUE self)
+rb_pycall_arrow_array_to_ruby(VALUE self)
+{
+  auto py_array = to_python(self);
+  std::shared_ptr<arrow::Array> arrow_array;
+  auto status = arrow::py::unwrap_array(py_array, &arrow_array);
+  GError *error = NULL;
+  if (!garrow_error_check(&error, status, "[pyarrow][array][to-ruby]"))
+    RG_RAISE_ERROR(error);
+  auto garrow_array = garrow_array_new_raw(&arrow_array);
+  return GOBJ2RVAL(garrow_array);
+}
+
+static VALUE
+rb_arrow_tensor_to_python(VALUE self)
 {
   auto tensor = GARROW_TENSOR(RVAL2GOBJ(self));
   auto arrow_tensor = garrow_tensor_get_raw(tensor);
   auto py_tensor = arrow::py::wrap_tensor(arrow_tensor);
-  return LONG2NUM((long)(py_tensor));
+  return to_ruby(py_tensor);
 }
 
 static VALUE
-rb_arrow_column_to_python_object_pointer(VALUE self)
+rb_pycall_arrow_tensor_to_ruby(VALUE self)
+{
+  auto py_tensor = to_python(self);
+  std::shared_ptr<arrow::Tensor> arrow_tensor;
+  auto status = arrow::py::unwrap_tensor(py_tensor, &arrow_tensor);
+  GError *error = NULL;
+  if (!garrow_error_check(&error, status, "[pyarrow][tensor][to-ruby]"))
+    RG_RAISE_ERROR(error);
+  auto garrow_tensor = garrow_tensor_new_raw(&arrow_tensor);
+  return GOBJ2RVAL(garrow_tensor);
+}
+
+static VALUE
+rb_arrow_column_to_python(VALUE self)
 {
   auto column = GARROW_COLUMN(RVAL2GOBJ(self));
   auto arrow_column = garrow_column_get_raw(column);
   auto py_column = arrow::py::wrap_column(arrow_column);
-  return LONG2NUM((long)(py_column));
+  return to_ruby(py_column);
+}
+
+static VALUE
+rb_pycall_arrow_column_to_ruby(VALUE self)
+{
+  auto py_column = to_python(self);
+  std::shared_ptr<arrow::Column> arrow_column;
+  auto status = arrow::py::unwrap_column(py_column, &arrow_column);
+  GError *error = NULL;
+  if (!garrow_error_check(&error, status, "[pyarrow][column][to-ruby]"))
+    RG_RAISE_ERROR(error);
+  auto garrow_column = garrow_column_new_raw(&arrow_column);
+  return GOBJ2RVAL(garrow_column);
 }
 
 static VALUE
-rb_arrow_table_to_python_object_pointer(VALUE self)
+rb_arrow_table_to_python(VALUE self)
 {
   auto table = GARROW_TABLE(RVAL2GOBJ(self));
   auto arrow_table = garrow_table_get_raw(table);
   auto py_table = arrow::py::wrap_table(arrow_table);
-  return LONG2NUM((long)(py_table));
+  return to_ruby(py_table);
+}
+
+static VALUE
+rb_pycall_arrow_table_to_ruby(VALUE self)
+{
+  auto py_table = to_python(self);
+  std::shared_ptr<arrow::Table> arrow_table;
+  auto status = arrow::py::unwrap_table(py_table, &arrow_table);
+  GError *error = NULL;
+  if (!garrow_error_check(&error, status, "[pyarrow][table][to-ruby]"))
+    RG_RAISE_ERROR(error);
+  auto garrow_table = garrow_table_new_raw(&arrow_table);
+  return GOBJ2RVAL(garrow_table);
 }
 
 static VALUE
-rb_arrow_record_batch_to_python_object_pointer(VALUE self)
+rb_arrow_record_batch_to_python(VALUE self)
 {
   auto record_batch = GARROW_RECORD_BATCH(RVAL2GOBJ(self));
   auto arrow_record_batch = garrow_record_batch_get_raw(record_batch);
   auto py_record_batch = arrow::py::wrap_record_batch(arrow_record_batch);
-  return LONG2NUM((long)(py_record_batch));
+  return to_ruby(py_record_batch);
+}
+
+static VALUE
+rb_pycall_arrow_record_batch_to_ruby(VALUE self)
+{
+  auto py_record_batch = to_python(self);
+  std::shared_ptr<arrow::RecordBatch> arrow_record_batch;
+  auto status =
+    arrow::py::unwrap_record_batch(py_record_batch, &arrow_record_batch);
+  GError *error = NULL;
+  if (!garrow_error_check(&error, status, "[pyarrow][record-batch][to-ruby]"))
+    RG_RAISE_ERROR(error);
+  auto garrow_record_batch = garrow_record_batch_new_raw(&arrow_record_batch);
+  return GOBJ2RVAL(garrow_record_batch);
 }
 
 extern "C" void
@@ -108,77 +236,143 @@ Init_arrow_pycall(void)
 {
   arrow::py::import_pyarrow();
 
-  VALUE rbArrow = rb_const_get(rb_cObject, rb_intern("Arrow"));
+  auto rbArrow = rb_const_get(rb_cObject, rb_intern("Arrow"));
+  auto rbPyArrow = rb_const_get(rb_cObject, rb_intern("PyArrow"));
 
   {
-    VALUE rbArrowBuffer = rb_const_get(rbArrow, rb_intern("Buffer"));
+    auto rbArrowBuffer = rb_const_get(rbArrow, rb_intern("Buffer"));
     rb_define_method(rbArrowBuffer,
-                     "to_python_object_pointer",
-                     (VALUE(*)(ANYARGS))rb_arrow_buffer_to_python_object_pointer,
+                     "to_python",
+                     (VALUE(*)(ANYARGS))rb_arrow_buffer_to_python,
+                     0);
+  }
+  {
+    auto rbPyArrowBuffer = rb_const_get(rbPyArrow, rb_intern("Buffer"));
+    rb_define_method(rbPyArrowBuffer,
+                     "to_ruby",
+                     (VALUE(*)(ANYARGS))rb_pycall_arrow_buffer_to_ruby,
                      0);
   }
 
   {
-    VALUE rbArrowDataType = rb_const_get(rbArrow, rb_intern("DataType"));
+    auto rbArrowDataType = rb_const_get(rbArrow, rb_intern("DataType"));
     rb_define_method(rbArrowDataType,
-                     "to_python_object_pointer",
-                     (VALUE(*)(ANYARGS))rb_arrow_data_type_to_python_object_pointer,
+                     "to_python",
+                     (VALUE(*)(ANYARGS))rb_arrow_data_type_to_python,
+                     0);
+  }
+  {
+    auto rbPyArrowDataType = rb_const_get(rbPyArrow, rb_intern("DataType"));
+    rb_define_method(rbPyArrowDataType,
+                     "to_ruby",
+                     (VALUE(*)(ANYARGS))rb_pycall_arrow_data_type_to_ruby,
                      0);
   }
 
   {
-    VALUE rbArrowField = rb_const_get(rbArrow, rb_intern("Field"));
+    auto rbArrowField = rb_const_get(rbArrow, rb_intern("Field"));
     rb_define_method(rbArrowField,
-                     "to_python_object_pointer",
-                     (VALUE(*)(ANYARGS))rb_arrow_field_to_python_object_pointer,
+                     "to_python",
+                     (VALUE(*)(ANYARGS))rb_arrow_field_to_python,
+                     0);
+  }
+  {
+    auto rbPyArrowField = rb_const_get(rbPyArrow, rb_intern("Field"));
+    rb_define_method(rbPyArrowField,
+                     "to_ruby",
+                     (VALUE(*)(ANYARGS))rb_pycall_arrow_field_to_ruby,
                      0);
   }
 
   {
-    VALUE rbArrowSchema = rb_const_get(rbArrow, rb_intern("Schema"));
+    auto rbArrowSchema = rb_const_get(rbArrow, rb_intern("Schema"));
     rb_define_method(rbArrowSchema,
-                     "to_python_object_pointer",
-                     (VALUE(*)(ANYARGS))rb_arrow_schema_to_python_object_pointer,
+                     "to_python",
+                     (VALUE(*)(ANYARGS))rb_arrow_schema_to_python,
+                     0);
+  }
+  {
+    auto rbPyArrowSchema = rb_const_get(rbPyArrow, rb_intern("Schema"));
+    rb_define_method(rbPyArrowSchema,
+                     "to_ruby",
+                     (VALUE(*)(ANYARGS))rb_pycall_arrow_schema_to_ruby,
                      0);
   }
 
   {
-    VALUE rbArrowArray = rb_const_get(rbArrow, rb_intern("Array"));
+    auto rbArrowArray = rb_const_get(rbArrow, rb_intern("Array"));
     rb_define_method(rbArrowArray,
-                     "to_python_object_pointer",
-                     (VALUE(*)(ANYARGS))rb_arrow_array_to_python_object_pointer,
+                     "to_python",
+                     (VALUE(*)(ANYARGS))rb_arrow_array_to_python,
+                     0);
+  }
+  {
+    auto rbPyArrowArrayConvertable =
+      rb_define_module_under(rbPyArrow, "ArrayConvertable");
+    rb_define_method(rbPyArrowArrayConvertable,
+                     "to_ruby",
+                     (VALUE(*)(ANYARGS))rb_pycall_arrow_array_to_ruby,
                      0);
   }
 
   {
-    VALUE rbArrowTensor = rb_const_get(rbArrow, rb_intern("Tensor"));
+    auto rbArrowTensor = rb_const_get(rbArrow, rb_intern("Tensor"));
     rb_define_method(rbArrowTensor,
-                     "to_python_object_pointer",
-                     (VALUE(*)(ANYARGS))rb_arrow_tensor_to_python_object_pointer,
+                     "to_python",
+                     (VALUE(*)(ANYARGS))rb_arrow_tensor_to_python,
+                     0);
+  }
+  {
+    auto rbPyArrowTensor = rb_const_get(rbPyArrow, rb_intern("Tensor"));
+    rb_define_method(rbPyArrowTensor,
+                     "to_ruby",
+                     (VALUE(*)(ANYARGS))rb_pycall_arrow_tensor_to_ruby,
                      0);
   }
 
   {
-    VALUE rbArrowColumn = rb_const_get(rbArrow, rb_intern("Column"));
+    auto rbArrowColumn = rb_const_get(rbArrow, rb_intern("Column"));
     rb_define_method(rbArrowColumn,
-                     "to_python_object_pointer",
-                     (VALUE(*)(ANYARGS))rb_arrow_column_to_python_object_pointer,
+                     "to_python",
+                     (VALUE(*)(ANYARGS))rb_arrow_column_to_python,
+                     0);
+  }
+  {
+    auto rbPyArrowColumn = rb_const_get(rbPyArrow, rb_intern("Column"));
+    rb_define_method(rbPyArrowColumn,
+                     "to_ruby",
+                     (VALUE(*)(ANYARGS))rb_pycall_arrow_column_to_ruby,
                      0);
   }
 
   {
-    VALUE rbArrowTable = rb_const_get(rbArrow, rb_intern("Table"));
+    auto rbArrowTable = rb_const_get(rbArrow, rb_intern("Table"));
     rb_define_method(rbArrowTable,
-                     "to_python_object_pointer",
-                     (VALUE(*)(ANYARGS))rb_arrow_table_to_python_object_pointer,
+                     "to_python",
+                     (VALUE(*)(ANYARGS))rb_arrow_table_to_python,
+                     0);
+  }
+  {
+    auto rbPyArrowTable = rb_const_get(rbPyArrow, rb_intern("Table"));
+    rb_define_method(rbPyArrowTable,
+                     "to_ruby",
+                     (VALUE(*)(ANYARGS))rb_pycall_arrow_table_to_ruby,
                      0);
   }
 
   {
-    VALUE rbArrowRecordBatch = rb_const_get(rbArrow, rb_intern("RecordBatch"));
+    auto rbArrowRecordBatch = rb_const_get(rbArrow, rb_intern("RecordBatch"));
     rb_define_method(rbArrowRecordBatch,
-                     "to_python_object_pointer",
-                     (VALUE(*)(ANYARGS))rb_arrow_record_batch_to_python_object_pointer,
+                     "to_python",
+                     (VALUE(*)(ANYARGS))rb_arrow_record_batch_to_python,
+                     0);
+  }
+  {
+    auto rbPyArrowRecordBatch =
+      rb_const_get(rbPyArrow, rb_intern("RecordBatch"));
+    rb_define_method(rbPyArrowRecordBatch,
+                     "to_ruby",
+                     (VALUE(*)(ANYARGS))rb_pycall_arrow_record_batch_to_ruby,
                      0);
   }
 }

data/ext/arrow-pycall/extconf.rb

@@ -1,4 +1,4 @@
-# Copyright 2017 Kouhei Sutou <kou@clear-code.com>
+# Copyright 2017-2018 Kouhei Sutou <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -30,4 +30,12 @@ end
   add_depend_package_path(name, source_dir, build_dir)
 end
 
+checking_for(checking_message("pycall"), "%s") do
+  pycall_version_path = File.join(__dir__, "..", "..", "pycall-version")
+  pycall_version = File.read(pycall_version_path).strip
+  pycall_spec = Gem::Specification.find_by_name("pycall", pycall_version)
+  $INCFLAGS += " -I#{pycall_spec.gem_dir}/ext/pycall"
+  pycall_spec.version
+end
+
 create_makefile("arrow_pycall")

data/lib/arrow-pycall.rb

@@ -17,49 +17,70 @@ require "pycall"
 
 require "arrow-pycall/version"
 
-begin
-  major, minor, _ = RUBY_VERSION.split(/\./)
-  require "#{major}.#{minor}/arrow_pycall.so"
-rescue LoadError
-  require "arrow_pycall.so"
-end
-
-require "arrow-pycall/convertable"
+module PyArrow
+  class << self
+    def __pyptr__
+      @pyarrow ||= PyCall.import_module("pyarrow")
+    end
+  end
 
-module Arrow
+  Buffer = __pyptr__.Buffer
   class Buffer
-    include ArrowPyCall::Convertable
+    register_python_type_mapping
   end
 
+  DataType = __pyptr__.lib.DataType
   class DataType
-    include ArrowPyCall::Convertable
+    register_python_type_mapping
   end
 
+  Field = __pyptr__.Field
   class Field
-    include ArrowPyCall::Convertable
+    register_python_type_mapping
   end
 
+  Schema = __pyptr__.Schema
   class Schema
-    include ArrowPyCall::Convertable
-  end
-
-  class Array
-    include ArrowPyCall::Convertable
+    register_python_type_mapping
   end
 
+  Tensor = __pyptr__.Tensor
   class Tensor
-    include ArrowPyCall::Convertable
+    register_python_type_mapping
   end
 
+  Column = __pyptr__.Column
   class Column
-    include ArrowPyCall::Convertable
+    register_python_type_mapping
   end
 
+  Table = __pyptr__.Table
   class Table
-    include ArrowPyCall::Convertable
+    register_python_type_mapping
   end
 
+  RecordBatch = __pyptr__.RecordBatch
   class RecordBatch
-    include ArrowPyCall::Convertable
+    register_python_type_mapping
+  end
+end
+
+begin
+  major, minor, _ = RUBY_VERSION.split(/\./)
+  require "#{major}.#{minor}/arrow_pycall.so"
+rescue LoadError
+  require "arrow_pycall.so"
+end
+
+module PyArrow
+  Arrow.constants.each do |name|
+    case name.to_s
+    when "ChunkedArray"
+    when /Array\z/
+      py_arrow_array = __pyptr__.lib.__dict__[name.to_s]
+      next if py_arrow_array.nil?
+      py_arrow_array.__send__(:register_python_type_mapping)
+      py_arrow_array.__send__(:include, ArrayConvertable)
+    end
   end
 end

data/lib/arrow-pycall/version.rb

@@ -1,4 +1,4 @@
-# Copyright 2017 Kouhei Sutou <kou@clear-code.com>
+# Copyright 2017-2018 Kouhei Sutou <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,5 +13,5 @@
 # limitations under the License.
 
 module ArrowPyCall
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/pycall-version

@@ -0,0 +1 @@
+>= 1.1.0.rc1

data/red-arrow-pycall.gemspec

@@ -1,6 +1,6 @@
 # -*- ruby -*-
 #
-# Copyright 2017 Kouhei Sutou <kou@clear-code.com>
+# Copyright 2017-2018 Kouhei Sutou <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -18,9 +18,13 @@ clean_white_space = lambda do |entry|
   entry.gsub(/(\A\n+|\n+\z)/, '') + "\n"
 end
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "lib"))
+base_dir = __dir__
+lib_dir = File.join(base_dir, "lib")
+$LOAD_PATH.unshift(lib_dir)
 require "arrow-pycall/version"
 
+pycall_version = File.read(File.join(base_dir, "pycall-version")).strip
+
 Gem::Specification.new do |spec|
   spec.name = "red-arrow-pycall"
   spec.version = ArrowPyCall::VERSION
@@ -37,6 +41,7 @@ Gem::Specification.new do |spec|
   spec.license = "Apache-2.0"
   spec.files = ["README.md", "Rakefile", "Gemfile", "#{spec.name}.gemspec"]
   spec.files += [".yardopts"]
+  spec.files += ["pycall-version"]
   spec.files += Dir.glob("lib/**/*.rb")
   spec.files += Dir.glob("ext/**/*.{c,cpp}")
   spec.files += Dir.glob("doc/text/*")
@@ -44,7 +49,7 @@ Gem::Specification.new do |spec|
   spec.test_files += Dir.glob("test/**/*")
 
   spec.add_runtime_dependency("red-arrow")
-  spec.add_runtime_dependency("pycall")
+  spec.add_runtime_dependency("pycall", pycall_version)
 
   spec.add_development_dependency("bundler")
   spec.add_development_dependency("rake")

data/test/test-to-python.rb

@@ -1,4 +1,4 @@
-# Copyright 2017 Kouhei Sutou <kou@clear-code.com>
+# Copyright 2017-2018 Kouhei Sutou <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,33 +16,33 @@ class ToPythonTest < Test::Unit::TestCase
   test("Buffer") do
     data = "hello"
     buffer = Arrow::Buffer.new(data)
-    assert_equal(data, buffer.to_python.to_pybytes.())
+    assert_equal(data, buffer.to_python.to_pybytes)
   end
 
   test("DataType") do
     data_type = Arrow::BooleanDataType.new
     assert_equal(data_type.to_s,
-                 data_type.to_python.__str__.())
+                 data_type.to_python.__str__)
   end
 
   test("Field") do
     field = Arrow::Field.new("enabled", Arrow::BooleanDataType.new)
     assert_equal("pyarrow.Field<#{field}>",
-                 field.to_python.__str__.())
+                 field.to_python.__str__)
   end
 
   test("Schema") do
     field = Arrow::Field.new("enabled", Arrow::BooleanDataType.new)
     schema = Arrow::Schema.new([field])
     assert_equal(schema.to_s,
-                 schema.to_python.__str__.())
+                 schema.to_python.__str__)
   end
 
   test("Array") do
     elements = [1, -2, 4]
     array = Arrow::Int8Array.new(elements)
     assert_equal(elements,
-                 array.to_python.to_pylist.())
+                 array.to_python.to_pylist)
   end
 
   test("Tensor") do
@@ -65,7 +65,7 @@ class ToPythonTest < Test::Unit::TestCase
                                shape,
                                strides,
                                names)
-    assert_equal(<<-TENSOR.chomp, tensor.to_python.to_numpy.().__str__.())
+    assert_equal(<<-TENSOR.chomp, tensor.to_python.to_numpy.to_s)
 [[[ 1  2]
   [ 3  4]]
 
@@ -82,7 +82,7 @@ class ToPythonTest < Test::Unit::TestCase
     array = Arrow::BooleanArray.new([true, false, true])
     column = Arrow::Column.new(field, array)
     assert_equal([true, false, true],
-                 column.to_python.to_pylist.())
+                 column.to_python.to_pylist)
   end
 
   test("Table") do
@@ -91,11 +91,11 @@ class ToPythonTest < Test::Unit::TestCase
     array = Arrow::BooleanArray.new([true, false, true])
     column = Arrow::Column.new(field, array)
     table = Arrow::Table.new(schema, [column])
-    assert_equal(<<-TABLE.chomp, table.to_python.to_pandas.().to_s)
-  enabled
-0    True
-1   False
-2    True
+    assert_equal(<<-TABLE.chomp, table.to_python.to_pandas.to_s)
+   enabled
+0     True
+1    False
+2     True
     TABLE
   end
 
@@ -104,11 +104,11 @@ class ToPythonTest < Test::Unit::TestCase
     schema = Arrow::Schema.new([field])
     array = Arrow::BooleanArray.new([true, false, true])
     record_batch = Arrow::RecordBatch.new(schema, 3, [array])
-    assert_equal(<<-RECORD_BATCH.chomp, record_batch.to_python.to_pandas.().to_s)
-  enabled
-0    True
-1   False
-2    True
+    assert_equal(<<-RECORD_BATCH.chomp, record_batch.to_python.to_pandas.to_s)
+   enabled
+0     True
+1    False
+2     True
     RECORD_BATCH
   end
 end

data/test/test-to-ruby.rb

@@ -0,0 +1,99 @@
+# Copyright 2017 Kouhei Sutou <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class ToRubyTest < Test::Unit::TestCase
+  test("Buffer") do
+    data = "hello"
+    buffer = Arrow::Buffer.new(data)
+    py_buffer = buffer.to_python
+    assert_equal(data, py_buffer.to_ruby.data.to_s)
+  end
+
+  test("DataType") do
+    data_type = Arrow::BooleanDataType.new
+    py_data_type = data_type.to_python
+    assert_equal(data_type.to_s, py_data_type.to_ruby.to_s)
+  end
+
+  test("Field") do
+    field = Arrow::Field.new("enabled", Arrow::BooleanDataType.new)
+    assert_equal(field.to_s,
+                 field.to_python.to_ruby.to_s)
+  end
+
+  test("Schema") do
+    field = Arrow::Field.new("enabled", Arrow::BooleanDataType.new)
+    schema = Arrow::Schema.new([field])
+    assert_equal(schema.to_s,
+                 schema.to_python.to_ruby.to_s)
+  end
+
+  test("Array") do
+    elements = [1, -2, 4]
+    array = Arrow::Int8Array.new(elements)
+    assert_equal(elements,
+                 array.to_python.to_ruby.to_a)
+  end
+
+  test("Tensor") do
+    raw_data = [
+      1, 2,
+      3, 4,
+
+      5, 6,
+      7, 8,
+
+      9, 10,
+      11, 12,
+    ]
+    data = Arrow::Buffer.new(raw_data.pack("c*"))
+    shape = [3, 2, 2]
+    strides = []
+    names = ["a", "b", "c"]
+    tensor = Arrow::Tensor.new(Arrow::Int8DataType.new,
+                               data,
+                               shape,
+                               strides,
+                               names)
+    assert_equal(tensor.buffer.data.to_s,
+                 tensor.to_python.to_ruby.buffer.data.to_s)
+  end
+
+  test("Column") do
+    field = Arrow::Field.new("enabled", Arrow::BooleanDataType.new)
+    array = Arrow::BooleanArray.new([true, false, true])
+    column = Arrow::Column.new(field, array)
+    assert_equal([true, false, true],
+                 column.to_python.to_ruby.to_a)
+  end
+
+  test("Table") do
+    field = Arrow::Field.new("enabled", Arrow::BooleanDataType.new)
+    schema = Arrow::Schema.new([field])
+    array = Arrow::BooleanArray.new([true, false, true])
+    column = Arrow::Column.new(field, array)
+    table = Arrow::Table.new(schema, [column])
+    assert_equal(table.each_column.collect(&:to_a),
+                 table.to_python.to_ruby.each_column.collect(&:to_a))
+  end
+
+  test("RecordBatch") do
+    field = Arrow::Field.new("enabled", Arrow::BooleanDataType.new)
+    schema = Arrow::Schema.new([field])
+    array = Arrow::BooleanArray.new([true, false, true])
+    record_batch = Arrow::RecordBatch.new(schema, 3, [array])
+    assert_equal(record_batch.to_s,
+                 record_batch.to_python.to_ruby.to_s)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-arrow-pycall
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Kouhei Sutou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-08 00:00:00.000000000 Z
+date: 2018-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: red-arrow
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.0.rc1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -143,12 +143,13 @@ files:
 - ext/arrow-pycall/arrow-pycall.cpp
 - ext/arrow-pycall/extconf.rb
 - lib/arrow-pycall.rb
-- lib/arrow-pycall/convertable.rb
 - lib/arrow-pycall/version.rb
+- pycall-version
 - red-arrow-pycall.gemspec
 - test/helper.rb
 - test/run-test.rb
 - test/test-to-python.rb
+- test/test-to-ruby.rb
 homepage: https://github.com/red-data-tools/red-arrow-pycall
 licenses:
 - Apache-2.0
@@ -169,12 +170,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.5.2.2
 signing_key: 
 specification_version: 4
 summary: Red Arrow PyCall is a library that provides converters between Ruby objects
   for Apache Arrow and Python objects for Apache Arrow.
 test_files:
+- test/test-to-ruby.rb
 - test/helper.rb
 - test/run-test.rb
 - test/test-to-python.rb

data/lib/arrow-pycall/convertable.rb

@@ -1,24 +0,0 @@
-# Copyright 2017 Kouhei Sutou <kou@clear-code.com>
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module ArrowPyCall
-  module Convertable
-    def to_pycall_object
-      pointer = FFI::Pointer.new(to_python_object_pointer)
-      pyobject_struct = PyCall::LibPython::PyObjectStruct.new(pointer)
-      pyobject_struct.to_ruby
-    end
-    alias_method :to_python, :to_pycall_object
-  end
-end