red-arrow-pycall 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f44174f03927e0a2c9c00306703c6d371787c1ff
-  data.tar.gz: 112085a608bd1fdc3ac523d73f4bb67eefae9f78
+SHA256:
+  metadata.gz: 34641a1e7cb87f7416c3f8f0070d26a72d8f5ae1eccb5f7d0c7ea938401065ef
+  data.tar.gz: 9bf70cc1586c1387aa34555149c804e4fb5455b9e5e611877c2e98224e8ec415
 SHA512:
-  metadata.gz: 535bb8bb7b4bee42750dee53e4417b74f6503bbb8f22d205f8bcb01e1c4dfb5547f5fce0d61cf08a30c2341b781eedcc68b381cbdc83ec625e28a3af9e6e4683
-  data.tar.gz: 2ef2a6bfff37eeccdafb446eb70e666c73bb01e85a3d7ccd7bb60e36bdd23a0a86953a8df0c2c0f54c2a4b403f1cb4965bd86bb9f47062e0d740bf4d82cf27e8
+  metadata.gz: 1244895e78aa4754f7978db3101a64891ae581d152177dc6515681b6b60e49621bdf878a62b5b2dc153a0443af90d7ced0a2b4908d403877898a24edb1f0bbf0
+  data.tar.gz: 21ec7609c641a1da6e1e2484b95f5d030fb5f6edd57b6562e2a84c53ff52360d5c10f147582df6afe9330732fde01e58c3af2f080576bcbf3fb34e1c1728c9ac

data/doc/text/news.md

@@ -1,5 +1,13 @@
 # News
 
+## 0.0.5 - 2019-03-21
+
+### Improvements
+
+  * Added support for auto Apache Arrow C++ Python module install.
+
+  * Added support for Apache Arrow 0.12.0 or later.
+
 ## 0.0.4 - 2018-03-07
 
 ### Improvements

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

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include <ruby.hpp>
+
 #include <arrow-glib/arrow-glib.hpp>
 
 #include <rbgobject.h>
@@ -94,7 +96,7 @@ rb_pycall_arrow_field_to_ruby(VALUE self)
   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);
+  auto garrow_field = garrow_field_new_raw(&arrow_field, nullptr);
   return GOBJ2RVAL(garrow_field);
 }
 
@@ -236,74 +238,74 @@ Init_arrow_pycall(void)
 {
   arrow::py::import_pyarrow();
 
-  auto rbArrow = rb_const_get(rb_cObject, rb_intern("Arrow"));
-  auto rbPyArrow = rb_const_get(rb_cObject, rb_intern("PyArrow"));
+  auto rbArrow = rb_const_get_at(rb_cObject, rb_intern("Arrow"));
+  auto rbPyArrow = rb_const_get_at(rb_cObject, rb_intern("PyArrow"));
 
   {
-    auto rbArrowBuffer = rb_const_get(rbArrow, rb_intern("Buffer"));
+    auto rbArrowBuffer = rb_const_get_at(rbArrow, rb_intern("Buffer"));
     rb_define_method(rbArrowBuffer,
                      "to_python",
-                     (VALUE(*)(ANYARGS))rb_arrow_buffer_to_python,
+                     reinterpret_cast<rb::RawMethod>(rb_arrow_buffer_to_python),
                      0);
   }
   {
-    auto rbPyArrowBuffer = rb_const_get(rbPyArrow, rb_intern("Buffer"));
+    auto rbPyArrowBuffer = rb_const_get_at(rbPyArrow, rb_intern("Buffer"));
     rb_define_method(rbPyArrowBuffer,
                      "to_ruby",
-                     (VALUE(*)(ANYARGS))rb_pycall_arrow_buffer_to_ruby,
+                     reinterpret_cast<rb::RawMethod>(rb_pycall_arrow_buffer_to_ruby),
                      0);
   }
 
   {
-    auto rbArrowDataType = rb_const_get(rbArrow, rb_intern("DataType"));
+    auto rbArrowDataType = rb_const_get_at(rbArrow, rb_intern("DataType"));
     rb_define_method(rbArrowDataType,
                      "to_python",
-                     (VALUE(*)(ANYARGS))rb_arrow_data_type_to_python,
+                     reinterpret_cast<rb::RawMethod>(rb_arrow_data_type_to_python),
                      0);
   }
   {
-    auto rbPyArrowDataType = rb_const_get(rbPyArrow, rb_intern("DataType"));
+    auto rbPyArrowDataType = rb_const_get_at(rbPyArrow, rb_intern("DataType"));
     rb_define_method(rbPyArrowDataType,
                      "to_ruby",
-                     (VALUE(*)(ANYARGS))rb_pycall_arrow_data_type_to_ruby,
+                     reinterpret_cast<rb::RawMethod>(rb_pycall_arrow_data_type_to_ruby),
                      0);
   }
 
   {
-    auto rbArrowField = rb_const_get(rbArrow, rb_intern("Field"));
+    auto rbArrowField = rb_const_get_at(rbArrow, rb_intern("Field"));
     rb_define_method(rbArrowField,
                      "to_python",
-                     (VALUE(*)(ANYARGS))rb_arrow_field_to_python,
+                     reinterpret_cast<rb::RawMethod>(rb_arrow_field_to_python),
                      0);
   }
   {
-    auto rbPyArrowField = rb_const_get(rbPyArrow, rb_intern("Field"));
+    auto rbPyArrowField = rb_const_get_at(rbPyArrow, rb_intern("Field"));
     rb_define_method(rbPyArrowField,
                      "to_ruby",
-                     (VALUE(*)(ANYARGS))rb_pycall_arrow_field_to_ruby,
+                     reinterpret_cast<rb::RawMethod>(rb_pycall_arrow_field_to_ruby),
                      0);
   }
 
   {
-    auto rbArrowSchema = rb_const_get(rbArrow, rb_intern("Schema"));
+    auto rbArrowSchema = rb_const_get_at(rbArrow, rb_intern("Schema"));
     rb_define_method(rbArrowSchema,
                      "to_python",
-                     (VALUE(*)(ANYARGS))rb_arrow_schema_to_python,
+                     reinterpret_cast<rb::RawMethod>(rb_arrow_schema_to_python),
                      0);
   }
   {
-    auto rbPyArrowSchema = rb_const_get(rbPyArrow, rb_intern("Schema"));
+    auto rbPyArrowSchema = rb_const_get_at(rbPyArrow, rb_intern("Schema"));
     rb_define_method(rbPyArrowSchema,
                      "to_ruby",
-                     (VALUE(*)(ANYARGS))rb_pycall_arrow_schema_to_ruby,
+                     reinterpret_cast<rb::RawMethod>(rb_pycall_arrow_schema_to_ruby),
                      0);
   }
 
   {
-    auto rbArrowArray = rb_const_get(rbArrow, rb_intern("Array"));
+    auto rbArrowArray = rb_const_get_at(rbArrow, rb_intern("Array"));
     rb_define_method(rbArrowArray,
                      "to_python",
-                     (VALUE(*)(ANYARGS))rb_arrow_array_to_python,
+                     reinterpret_cast<rb::RawMethod>(rb_arrow_array_to_python),
                      0);
   }
   {
@@ -311,68 +313,68 @@ Init_arrow_pycall(void)
       rb_define_module_under(rbPyArrow, "ArrayConvertable");
     rb_define_method(rbPyArrowArrayConvertable,
                      "to_ruby",
-                     (VALUE(*)(ANYARGS))rb_pycall_arrow_array_to_ruby,
+                     reinterpret_cast<rb::RawMethod>(rb_pycall_arrow_array_to_ruby),
                      0);
   }
 
   {
-    auto rbArrowTensor = rb_const_get(rbArrow, rb_intern("Tensor"));
+    auto rbArrowTensor = rb_const_get_at(rbArrow, rb_intern("Tensor"));
     rb_define_method(rbArrowTensor,
                      "to_python",
-                     (VALUE(*)(ANYARGS))rb_arrow_tensor_to_python,
+                     reinterpret_cast<rb::RawMethod>(rb_arrow_tensor_to_python),
                      0);
   }
   {
-    auto rbPyArrowTensor = rb_const_get(rbPyArrow, rb_intern("Tensor"));
+    auto rbPyArrowTensor = rb_const_get_at(rbPyArrow, rb_intern("Tensor"));
     rb_define_method(rbPyArrowTensor,
                      "to_ruby",
-                     (VALUE(*)(ANYARGS))rb_pycall_arrow_tensor_to_ruby,
+                     reinterpret_cast<rb::RawMethod>(rb_pycall_arrow_tensor_to_ruby),
                      0);
   }
 
   {
-    auto rbArrowColumn = rb_const_get(rbArrow, rb_intern("Column"));
+    auto rbArrowColumn = rb_const_get_at(rbArrow, rb_intern("Column"));
     rb_define_method(rbArrowColumn,
                      "to_python",
-                     (VALUE(*)(ANYARGS))rb_arrow_column_to_python,
+                     reinterpret_cast<rb::RawMethod>(rb_arrow_column_to_python),
                      0);
   }
   {
-    auto rbPyArrowColumn = rb_const_get(rbPyArrow, rb_intern("Column"));
+    auto rbPyArrowColumn = rb_const_get_at(rbPyArrow, rb_intern("Column"));
     rb_define_method(rbPyArrowColumn,
                      "to_ruby",
-                     (VALUE(*)(ANYARGS))rb_pycall_arrow_column_to_ruby,
+                     reinterpret_cast<rb::RawMethod>(rb_pycall_arrow_column_to_ruby),
                      0);
   }
 
   {
-    auto rbArrowTable = rb_const_get(rbArrow, rb_intern("Table"));
+    auto rbArrowTable = rb_const_get_at(rbArrow, rb_intern("Table"));
     rb_define_method(rbArrowTable,
                      "to_python",
-                     (VALUE(*)(ANYARGS))rb_arrow_table_to_python,
+                     reinterpret_cast<rb::RawMethod>(rb_arrow_table_to_python),
                      0);
   }
   {
-    auto rbPyArrowTable = rb_const_get(rbPyArrow, rb_intern("Table"));
+    auto rbPyArrowTable = rb_const_get_at(rbPyArrow, rb_intern("Table"));
     rb_define_method(rbPyArrowTable,
                      "to_ruby",
-                     (VALUE(*)(ANYARGS))rb_pycall_arrow_table_to_ruby,
+                     reinterpret_cast<rb::RawMethod>(rb_pycall_arrow_table_to_ruby),
                      0);
   }
 
   {
-    auto rbArrowRecordBatch = rb_const_get(rbArrow, rb_intern("RecordBatch"));
+    auto rbArrowRecordBatch = rb_const_get_at(rbArrow, rb_intern("RecordBatch"));
     rb_define_method(rbArrowRecordBatch,
                      "to_python",
-                     (VALUE(*)(ANYARGS))rb_arrow_record_batch_to_python,
+                     reinterpret_cast<rb::RawMethod>(rb_arrow_record_batch_to_python),
                      0);
   }
   {
     auto rbPyArrowRecordBatch =
-      rb_const_get(rbPyArrow, rb_intern("RecordBatch"));
+      rb_const_get_at(rbPyArrow, rb_intern("RecordBatch"));
     rb_define_method(rbPyArrowRecordBatch,
                      "to_ruby",
-                     (VALUE(*)(ANYARGS))rb_pycall_arrow_record_batch_to_ruby,
+                     reinterpret_cast<rb::RawMethod>(rb_pycall_arrow_record_batch_to_ruby),
                      0);
   }
 }

data/ext/arrow-pycall/extconf.rb

@@ -12,12 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require "extpp"
 require "mkmf-gnome2"
 
 unless required_pkg_config_package("arrow-glib")
   exit(false)
 end
-unless required_pkg_config_package("arrow-python")
+unless required_pkg_config_package("arrow-python",
+                                   :debian => "libarrow-python-dev",
+                                   :redhat => "arrow-python-devel")
   exit(false)
 end
 

data/lib/arrow-pycall/version.rb

@@ -13,5 +13,5 @@
 # limitations under the License.
 
 module ArrowPyCall
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/red-arrow-pycall.gemspec

@@ -48,7 +48,9 @@ Gem::Specification.new do |spec|
   spec.extensions = ["ext/arrow-pycall/extconf.rb"]
   spec.test_files += Dir.glob("test/**/*")
 
+  spec.add_runtime_dependency("extpp")
   spec.add_runtime_dependency("red-arrow")
+  spec.add_runtime_dependency("red-parquet")
   spec.add_runtime_dependency("pycall", pycall_version)
 
   spec.add_development_dependency("bundler")

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: red-arrow-pycall
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Kouhei Sutou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-07 00:00:00.000000000 Z
+date: 2019-03-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: extpp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: red-arrow
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: red-parquet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pycall
   requirement: !ruby/object:Gem::Requirement
@@ -170,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Red Arrow PyCall is a library that provides converters between Ruby objects