pycall 1.1.0.rc1 → 1.2.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78588bb0a23c7fa9b5c522113598027e8c98aea9fb9b72e96b64a1db4e9cff41
-  data.tar.gz: '08d504ae9fdaa7ea8f532ca10848df3119264d956b259b40b3dfb356f5ea5834'
+  metadata.gz: 4ee819add9bcf3e4c3a3fb4f4fdc7b94abe6ccf1a969a8aabe9bd7edf9aa6701
+  data.tar.gz: '03839cbba19832eca0cf90ee7e85cf4cd953f2f5bba2dd12bcc9005097393482'
 SHA512:
-  metadata.gz: d3d9c586c37ec66a8a6a7bd1093b5fd0848aad2602ab6784fe73a50c08a05402289601d1e87d7bfe13f51b54f2f8002790e7c95ac4899de339ad8af7dedccae3
-  data.tar.gz: b3c3d61680274ff6e612dabd28818522637f479225f43a9a8025d2a036127b3fddc62d2342456673cf96cdc280ce8e388fa503e904b5d5860b44c0b0fa8c3a29
+  metadata.gz: d22a8905b5d7c9f9f2793fd8bb0ed003fa418ab35f8048faced61145d577502571ab0d0bbfb187bb689ee59f8e99539b3de9789d4905584340041e801e951c0f
+  data.tar.gz: d382691fcdd3995347d126ff70fa0dfc1e877b9136bfce4ca6ac6d783aa7802da544250b03601ae9d335ae4fd9c72af15ab412450e14c2d20a05a29b16b58763

data/.travis.yml

@@ -10,8 +10,6 @@ rvm:
 - 2.5.0
 - 2.4.3
 - 2.3.5
-- 2.2.9
-- 2.1.10
 
 env:
   global:
@@ -42,8 +40,6 @@ matrix:
     env: PYENV_VERSION=miniconda3-4.3.11
   allow_failures:
   - os: osx
-  - rvm: 2.2.9
-  - rvm: 2.1.10
 
 before_install:
 - gem update --system

data/CHANGES.md

@@ -22,6 +22,16 @@
 
   *Kouhei Sutou*
 
+* Support multiple candidates of Python command in `PyCall.init`
+
+* Now, `PyCall.init` tries `python3` command before `python` in default
+
+* Drop Ruby 2.2 and 2.1 supports
+
+* Add `PyCall::PyTypeObjectWrapper#<` as `Class#<`
+
+* Support class inheritance in python type mapping
+
 ## 1.0.3
 
 * Fix anaconda support to define the environment variable `PYTHONHOME`.

data/README.md

@@ -1,3 +1,8 @@
+<a name="logo"/>
+<div align="center">
+<img src="./images/pycallrb_logo_200.png" alt="pycall.rb logo" width="200" height="200"></img>
+</div>
+
 # PyCall: Calling Python functions from the Ruby language
 
 [![Build Status](https://travis-ci.org/mrkn/pycall.rb.svg?branch=master)](https://travis-ci.org/mrkn/pycall.rb)
@@ -8,6 +13,16 @@ with Python from the Ruby language.  You can import arbitrary Python modules
 into Ruby modules, call Python functions with automatic type conversion from
 Ruby to Python.
 
+## Supported Ruby versions
+
+pycall.rb supports Ruby version 2.3 or higher.
+
+## Supported Python versions
+
+pycall.rb supports Python version 2.7 or higher.
+
+Note that in Python 2.7 old-style class, that is defined without a super class, is not fully supported in pycall.rb.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/ext/pycall/libpython.c

@@ -94,6 +94,7 @@ pycall_init_libpython_api_table(VALUE libpython_handle)
   INIT_API_TABLE_ENTRY(_PyObject_New, required);
   INIT_API_TABLE_ENTRY(PyCallable_Check, required);
   INIT_API_TABLE_ENTRY(PyObject_IsInstance, required);
+  INIT_API_TABLE_ENTRY(PyObject_IsSubclass, required);
   INIT_API_TABLE_ENTRY2(PyObject_Hash._hash_t, PyObject_Hash, required);
   INIT_API_TABLE_ENTRY(PyObject_RichCompare, required);
   INIT_API_TABLE_ENTRY(PyObject_Call, required);

data/ext/pycall/pycall.c

@@ -452,7 +452,7 @@ get_pytypeobj_ptr(VALUE obj)
 static inline PyTypeObject*
 try_get_pytypeobj_ptr(VALUE obj)
 {
-  if (is_pycall_pytypeptr(obj)) return NULL;
+  if (!is_pycall_pytypeptr(obj)) return NULL;
   return (PyTypeObject*)DATA_PTR(obj);
 }
 
@@ -541,6 +541,20 @@ pycall_pytypeptr_eqq(VALUE obj, VALUE other)
   return Qfalse;
 }
 
+static VALUE
+pycall_pytypeptr_subclass_p(VALUE obj, VALUE other)
+{
+  PyTypeObject* pytype = get_pytypeobj_ptr(obj);
+  if (is_pycall_pyptr(other)) {
+    PyTypeObject* pytype_other = try_get_pytypeobj_ptr(other);
+    if (pytype_other) {
+      int res =  Py_API(PyObject_IsSubclass)((PyObject *)pytype, (PyObject *)pytype_other);
+      return res ? Qtrue : Qfalse;
+    }
+  }
+  return Qfalse;
+}
+
 /* ==== PyCall::LibPython::API ==== */
 
 static VALUE
@@ -1277,11 +1291,39 @@ pycall_pyobject_wrapper_check_get_pyobj_ptr(VALUE obj, PyTypeObject *pytypeobj)
 
 /* ==== PyCall::Conversion ==== */
 
+static int
+get_mapped_ancestor_class_iter(VALUE key, VALUE value, VALUE arg)
+{
+  VALUE *args = (VALUE *)arg;
+  if (RTEST(pycall_pytypeptr_subclass_p(args[0], key))) {
+    args[1] = value;
+    return ST_STOP;
+  }
+  return ST_CONTINUE;
+}
+
+static VALUE
+pycall_python_type_mapping_get_mapped_ancestor_class(VALUE pytypeptr)
+{
+  VALUE args[2];
+  args[0] = pytypeptr;
+  args[1] = Qnil;
+
+  rb_hash_foreach(python_type_mapping, get_mapped_ancestor_class_iter, (VALUE)args);
+
+  return args[1];
+}
+
 static VALUE
 pycall_python_type_mapping_get_mapped_class(VALUE pytypeptr)
 {
+  VALUE mapped;
   (void)check_get_pytypeobj_ptr(pytypeptr);
-  return rb_hash_lookup(python_type_mapping, pytypeptr);
+  mapped = rb_hash_lookup(python_type_mapping, pytypeptr);
+  if (NIL_P(mapped)) {
+    mapped = pycall_python_type_mapping_get_mapped_ancestor_class(pytypeptr);
+  }
+  return mapped;
 }
 
 static int
@@ -2179,6 +2221,7 @@ Init_pycall(void)
   rb_define_method(cPyTypePtr, "__tp_basicsize__", pycall_pytypeptr_get_tp_basicsize, 0);
   rb_define_method(cPyTypePtr, "__tp_flags__", pycall_pytypeptr_get_tp_flags, 0);
   rb_define_method(cPyTypePtr, "===", pycall_pytypeptr_eqq, 1);
+  rb_define_method(cPyTypePtr, "<", pycall_pytypeptr_subclass_p, 1);
 
   /* PyCall::LibPython::API */
 

data/ext/pycall/pycall_internal.h

@@ -529,6 +529,7 @@ typedef struct {
   PyObject * (* _PyObject_New)(PyTypeObject *);
   int (* PyCallable_Check)(PyObject *);
   int (* PyObject_IsInstance)(PyObject *, PyObject *);
+  int (* PyObject_IsSubclass)(PyObject *, PyObject *);
   union {
     long      (* _long)(PyObject *);
     Py_hash_t (* _hash_t)(PyObject *);

data/ext/pycall/ruby_wrapper.c

@@ -1,4 +1,5 @@
 #include "pycall_internal.h"
+#include "pycall.h"
 
 static PyMemberDef PyRuby_members[] = {
   {"ruby_object_ptr", Py_T_PYSSIZET, offsetof(PyRubyObject, ruby_object), Py_READONLY},

data/lib/pycall/libpython/finder.rb

@@ -19,25 +19,26 @@ module PyCall
       LIBSUFFIX = libsuffix || 'so'
 
       class << self
+        DEFAULT_PYTHON = [
+          -'python3',
+          -'python',
+        ].freeze
+
+        def find_python_config(python = nil)
+          python ||= DEFAULT_PYTHON
+          Array(python).each do |python_cmd|
+            python_config = investigate_python_config(python_cmd)
+            return [python_cmd, python_config] unless python_config.empty?
+          end
+        rescue
+          raise ::PyCall::PythonNotFound
+        else
+          raise ::PyCall::PythonNotFound
+        end
+
         def find_libpython(python = nil)
           debug_report("find_libpython(#{python.inspect})")
-	  if python
-	    begin
-	      python_config = investigate_python_config(python)
-	    rescue
-              raise ::PyCall::PythonNotFound
-	    end
-          else
-            %w[python python3].each do |python_cmd|
-	      begin
-		python_config = investigate_python_config(python_cmd)
-		python = python_cmd
-                break
-	      rescue
-		raise ::PyCall::PythonNotFound
-	      end
-	    end
-	  end
+          python, python_config = find_python_config(python)
 
           set_PYTHONHOME(python_config)
           libs = make_libs(python_config)
@@ -101,6 +102,7 @@ module PyCall
           IO.popen(python_env, [python, python_investigator_py], 'r') do |io|
             {}.tap do |config|
               io.each_line do |line|
+                next unless line =~ /: /
                 key, value = line.chomp.split(': ', 2)
                 case value
                 when 'True', 'true', 'False', 'false'

data/lib/pycall/pytypeobject_wrapper.rb

@@ -49,6 +49,15 @@ module PyCall
       end
     end
 
+    def <(other)
+      case other
+      when PyTypeObjectWrapper
+        __pyptr__ < other.__pyptr__
+      else
+        raise TypeError, "compared with non class/module"
+      end
+    end
+
     private
 
     def register_python_type_mapping

data/lib/pycall/version.rb

@@ -1,3 +1,3 @@
 module PyCall
-  VERSION = "1.1.0.rc1"
+  VERSION = "1.2.0.beta1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pycall
 version: !ruby/object:Gem::Version
-  version: 1.1.0.rc1
+  version: 1.2.0.beta1
 platform: ruby
 authors:
 - Kenta Murata
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-07 00:00:00.000000000 Z
+date: 2018-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -171,8 +171,9 @@ files:
 - ext/pycall/pycall_internal.h
 - ext/pycall/range.c
 - ext/pycall/ruby_wrapper.c
+- images/pycallrb_logo.png
+- images/pycallrb_logo_200.png
 - lib/pycall.rb
-- lib/pycall/conversion.rb
 - lib/pycall/dict.rb
 - lib/pycall/error.rb
 - lib/pycall/gc_guard.rb
@@ -193,7 +194,6 @@ files:
 - lib/pycall/pytypeobject_wrapper.rb
 - lib/pycall/set.rb
 - lib/pycall/slice.rb
-- lib/pycall/tuple.rb
 - lib/pycall/version.rb
 - lib/pycall/wrapper_object_cache.rb
 - pycall.gemspec
@@ -219,7 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.4
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: pycall

data/lib/pycall/conversion.rb

@@ -1,173 +0,0 @@
-module PyCall
-  module Conversions
-    @python_type_map = []
-
-    class TypePair < Struct.new(:pytype, :rbtype)
-      def to_a
-        [pytype, rbtype]
-      end
-    end
-
-    def self.each_type_pair
-      i, n = 1, @python_type_map.length
-      while i <= n
-        yield @python_type_map[n - i]
-        i += 1
-      end
-      self
-    end
-
-    def self.python_type_mapping(pytype, rbtype)
-      each_type_pair do |type_pair|
-        next unless pytype == type_pair.pytype
-        type_pair.rbtype = rbtype
-        return
-      end
-      @python_type_map << TypePair.new(pytype, rbtype)
-    end
-
-    # Convert a PyCall::PyObjectStruct object to a Ruby object
-    #
-    # @param [PyCall::PyObjectStruct] pyptr  a PyObjectStruct object.
-    #
-    # @return a Ruby object converted from `pyptr`.
-    def self.to_ruby(pyptr)
-      return nil if pyptr.null? || pyptr.none?
-
-      case
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyType_Type)
-        return TypeObject.new(pyptr)
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyBool_Type)
-        return Conversions.convert_to_boolean(pyptr)
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyInt_Type)
-        return Conversions.convert_to_integer(pyptr)
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyLong_Type)
-        # TODO: should make Bignum
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyFloat_Type)
-        return Conversions.convert_to_float(pyptr)
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyComplex_Type)
-        return Conversions.convert_to_complex(pyptr)
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyString_Type)
-        return Conversions.convert_to_string(pyptr)
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyUnicode_Type)
-        py_str_ptr = LibPython.PyUnicode_AsUTF8String(pyptr)
-        return Conversions.convert_to_string(py_str_ptr).force_encoding(Encoding::UTF_8)
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyList_Type)
-        return PyCall::List.new(pyptr)
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyTuple_Type)
-        return Conversions.convert_to_tuple(pyptr)
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PyDict_Type)
-        return PyCall::Dict.new(pyptr)
-
-      when PyCall::Types.pyisinstance(pyptr, LibPython.PySet_Type)
-        return PyCall::Set.new(pyptr)
-      end
-
-      pyobj = PyObject.new(pyptr)
-      each_type_pair do |tp|
-        pytype, rbtype = tp.to_a
-        next unless pyobj.kind_of?(pytype)
-        case
-        when rbtype.kind_of?(Proc)
-          return rbtype.(pyobj)
-        when rbtype.respond_to?(:from_python)
-          return rbtype.from_python(pyobj)
-        else
-          return rbtype.new(pyobj)
-        end
-      end
-      pyobj
-    end
-
-    def self.from_ruby(obj)
-      case obj
-      when LibPython::PyObjectStruct
-        obj
-      when PyObject, PyObjectWrapper
-        obj.__pyobj__
-      when TrueClass, FalseClass
-        LibPython.PyBool_FromLong(obj ? 1 : 0)
-      when Integer
-        LibPython.PyInt_FromSsize_t(obj)
-      when Float
-        LibPython.PyFloat_FromDouble(obj)
-      when String
-        if obj.encoding != Encoding::BINARY && (PyCall.unicode_literals? || !obj.ascii_only?)
-          obj = obj.encode(Encoding::UTF_8) if obj.encoding != Encoding::UTF_8
-          return LibPython.PyUnicode_DecodeUTF8(obj, obj.bytesize, nil)
-        end
-        LibPython.PyString_FromStringAndSize(obj, obj.bytesize)
-      when Symbol
-        from_ruby(obj.to_s)
-      when Array
-        PyCall::List.new(obj).__pyobj__
-      when Hash
-        PyCall::Dict.new(obj).__pyobj__
-      when Proc
-        PyCall.wrap_ruby_callable(obj)
-      else
-        PyCall.None
-      end
-    end
-
-    def self.convert_to_boolean(py_obj)
-      0 != LibPython.PyInt_AsSsize_t(py_obj)
-    end
-
-    def self.convert_to_integer(py_obj)
-      LibPython.PyInt_AsSsize_t(py_obj)
-    end
-
-    def self.convert_to_float(py_obj)
-      LibPython.PyFloat_AsDouble(py_obj)
-    end
-
-    def self.convert_to_complex(py_obj)
-      real = LibPython.PyComplex_RealAsDouble(py_obj)
-      imag = LibPython.PyComplex_ImagAsDouble(py_obj)
-      Complex(real, imag)
-    end
-
-    def self.convert_to_string(py_obj)
-      FFI::MemoryPointer.new(:string) do |str_ptr|
-        FFI::MemoryPointer.new(:int) do |len_ptr|
-          res = LibPython.PyString_AsStringAndSize(py_obj, str_ptr, len_ptr)
-          return nil if res == -1  # FIXME: error
-
-          len = len_ptr.get(:int, 0)
-          return str_ptr.get_pointer(0).read_string(len)
-        end
-      end
-    end
-
-    def self.convert_to_array(py_obj, force_list: true, array_class: Array)
-      case
-      when force_list || py_obj.kind_of?(LibPython.PyList_Type)
-        len = LibPython.PySequence_Size(py_obj)
-        array_class.new(len) do |i|
-          LibPython.PySequence_GetItem(py_obj, i).to_ruby
-        end
-      end
-    end
-
-    def self.convert_to_tuple(py_obj)
-      PyCall::Tuple.new(py_obj)
-    end
-  end
-
-  class LibPython::PyObjectStruct
-    def to_ruby
-      Conversions.to_ruby(self)
-    end
-  end
-end

data/lib/pycall/tuple.rb

@@ -1,46 +0,0 @@
-module PyCall
-  class Tuple
-    include PyObjectWrapper
-
-    def self.new(init)
-      case init
-      when Integer
-        super(LibPython.PyTuple_New(init))
-      when Array
-        tuple = new(init.length)
-        init.each_with_index do |obj, index|
-          tuple[index] = obj
-        end
-        tuple
-      when LibPython::PyObjectStruct
-        super(init)
-      end
-    end
-
-    # Make tuple from array
-    def self.[](*ary)
-      new(ary)
-    end
-
-    def size
-      LibPython.PyTuple_Size(__pyobj__)
-    end
-
-    alias length size
-
-    def [](index)
-      LibPython.PyTuple_GetItem(__pyobj__, index).to_ruby
-    end
-
-    def []=(index, value)
-      value = Conversions.from_ruby(value)
-      LibPython.PyTuple_SetItem(__pyobj__, index, value)
-    end
-
-    def to_a
-      Array.new(length) {|i| self[i] }
-    end
-
-    alias to_ary to_a
-  end
-end