red-arrow-pycall 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 368f8d37b4b408f129398fa4e57b135a5ed72a14
-  data.tar.gz: 472cd44043698b07eb185048c2fd55ab3f20173b
+  metadata.gz: cf65599f0a91aa12e9f93971e981e01b0e83807b
+  data.tar.gz: 8c9c6cd4a9d052560a85f9e03334cfcc97895e35
 SHA512:
-  metadata.gz: ff937cfea30d55e0f6dee3569a916ec84a761147bbd1b7c5a0c90f0553f0f20b550be1eb73ec28b7a63ffdde6bfa9c3b47120a9e14c908070ec39889f50837ab
-  data.tar.gz: f66582aae7c4075d63c95c88182b97883ffd06d727a8a97bc608535e011e67b4e7da1ee2914e993d57934009386d21aab047c9193682d19b90c5ba65dda55e1c
+  metadata.gz: cefa69198ad06b139bf67c82459335ca2f6774f75e09d3776c404ca8c94a18700a8d1d5f82361a445e10ea0ad90f01cf15a548c0d5453b4d5484911e95059f4d
+  data.tar.gz: a541e339f38555aa5300cf144800e509ceca9be610bbc1fc01cf5f3bb1fb7586b363487e4c7805fdae5dc543be725975a66b1d5c29fe96d29a92283b987c8cac

data/doc/text/news.md

@@ -1,5 +1,11 @@
 # News
 
+## 0.0.2 - 2017-07-08
+
+### Fixes
+
+  * Added a missing source file.
+
 ## 0.0.1 - 2017-07-08
 
 Initial release!!!

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

@@ -0,0 +1,184 @@
+/*
+ * 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.
+ */
+
+#include <arrow-glib/arrow-glib.hpp>
+
+#include <rbgobject.h>
+
+#include <arrow/python/pyarrow.h>
+
+extern "C" void Init_arrow_pycall(void);
+
+static VALUE
+rb_arrow_buffer_to_python_object_pointer(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));
+}
+
+static VALUE
+rb_arrow_data_type_to_python_object_pointer(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));
+}
+
+static VALUE
+rb_arrow_field_to_python_object_pointer(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));
+}
+
+static VALUE
+rb_arrow_schema_to_python_object_pointer(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));
+}
+
+static VALUE
+rb_arrow_array_to_python_object_pointer(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));
+}
+
+static VALUE
+rb_arrow_tensor_to_python_object_pointer(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));
+}
+
+static VALUE
+rb_arrow_column_to_python_object_pointer(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));
+}
+
+static VALUE
+rb_arrow_table_to_python_object_pointer(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));
+}
+
+static VALUE
+rb_arrow_record_batch_to_python_object_pointer(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));
+}
+
+extern "C" void
+Init_arrow_pycall(void)
+{
+  arrow::py::import_pyarrow();
+
+  VALUE rbArrow = rb_const_get(rb_cObject, rb_intern("Arrow"));
+
+  {
+    VALUE 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,
+                     0);
+  }
+
+  {
+    VALUE 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,
+                     0);
+  }
+
+  {
+    VALUE 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,
+                     0);
+  }
+
+  {
+    VALUE 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,
+                     0);
+  }
+
+  {
+    VALUE 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,
+                     0);
+  }
+
+  {
+    VALUE 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,
+                     0);
+  }
+
+  {
+    VALUE 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,
+                     0);
+  }
+
+  {
+    VALUE 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,
+                     0);
+  }
+
+  {
+    VALUE 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,
+                     0);
+  }
+}

data/lib/arrow-pycall/version.rb

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

data/red-arrow-pycall.gemspec

@@ -38,7 +38,7 @@ Gem::Specification.new do |spec|
   spec.files = ["README.md", "Rakefile", "Gemfile", "#{spec.name}.gemspec"]
   spec.files += [".yardopts"]
   spec.files += Dir.glob("lib/**/*.rb")
-  spec.files += Dir.glob("ext/**/*.c")
+  spec.files += Dir.glob("ext/**/*.{c,cpp}")
   spec.files += Dir.glob("doc/text/*")
   spec.extensions = ["ext/arrow-pycall/extconf.rb"]
   spec.test_files += Dir.glob("test/**/*")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: red-arrow-pycall
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Kouhei Sutou
@@ -140,6 +140,7 @@ files:
 - Rakefile
 - doc/text/apache-2.0.txt
 - doc/text/news.md
+- ext/arrow-pycall/arrow-pycall.cpp
 - ext/arrow-pycall/extconf.rb
 - lib/arrow-pycall.rb
 - lib/arrow-pycall/convertable.rb