pycall 0.1.0.alpha.20170502 → 0.1.0.alpha.20170711

data/lib/pycall/init.rb

@@ -11,10 +11,20 @@ module PyCall
     end
 
     @builtin = LibPython.PyImport_ImportModule(PYTHON_VERSION < '3.0.0' ? '__builtin__' : 'builtins').to_ruby
+
+    begin
+      import_module('stackless')
+      @has_stackless_extension = true
+    rescue PyError
+      @has_stackless_extension = false
+    end
+
+    __initialize_ruby_wrapper__
   end
 
   class << self
     attr_reader :builtin
+    attr_reader :has_stackless_extension
   end
 
   __initialize_pycall__

data/lib/pycall/libpython/pyobject_struct.rb

@@ -0,0 +1,30 @@
+require 'ffi'
+
+module PyCall
+  module LibPython
+    class PyObjectStruct < FFI::Struct
+    end
+
+    class PyTypeObjectStruct < PyObjectStruct
+    end
+
+    class PyObjectStruct < FFI::Struct
+      layout ob_refcnt: :ssize_t,
+             ob_type:   PyTypeObjectStruct.by_ref
+
+      def self.null
+        new(FFI::Pointer::NULL)
+      end
+
+      def py_none?
+        PyCall.none?(self)
+      end
+
+      def kind_of?(klass)
+        klass = klass.__pyobj__ if klass.kind_of? PyObjectWrapper
+        return super unless klass.kind_of? PyObjectStruct
+        PyCall::Types.pyisinstance(self, klass)
+      end
+    end
+  end
+end

data/lib/pycall/libpython/pytypeobject_struct.rb

@@ -0,0 +1,273 @@
+require 'pycall/libpython/pyobject_struct'
+
+module PyCall
+  module LibPython
+    # types:
+    T_SHORT  = 0
+    T_INT    = 1
+    T_LONG   = 2
+    T_FLOAT  = 3
+    T_DOUBLE = 4
+    T_STRING = 5
+    T_OBJECT = 6
+    T_CHAR   = 7
+    T_BYTE   = 8
+    T_UBYTE  = 9
+    T_USHORT = 10
+    T_UINT   = 11
+    T_ULONG  = 12
+    T_STRING_INPLACE = 13
+    T_BOOL      = 14
+    T_OBJECT_EX = 16
+    T_LONGLONG  = 17 # added in Python 2.5
+    T_ULONGLONG = 18 # added in Python 2.5
+    T_PYSSIZET  = 19 # added in Python 2.6
+    T_NONE      = 20 # added in Python 3.0
+
+    # flags:
+    READONLY = 1
+    READ_RESTRICTED = 2
+    PY_WRITE_RESTRICTED = 4
+    RESTRICTED = (READ_RESTRICTED | PY_WRITE_RESTRICTED)
+
+    # Python 2.7
+    Py_TPFLAGS_HAVE_GETCHARBUFFER  = 0x00000001<<0
+    Py_TPFLAGS_HAVE_SEQUENCE_IN    = 0x00000001<<1
+    Py_TPFLAGS_GC                  = 0 # was sometimes (0x00000001<<2) in Python <= 2.1
+    Py_TPFLAGS_HAVE_INPLACEOPS     = 0x00000001<<3
+    Py_TPFLAGS_CHECKTYPES          = 0x00000001<<4
+    Py_TPFLAGS_HAVE_RICHCOMPARE    = 0x00000001<<5
+    Py_TPFLAGS_HAVE_WEAKREFS       = 0x00000001<<6
+    Py_TPFLAGS_HAVE_ITER           = 0x00000001<<7
+    Py_TPFLAGS_HAVE_CLASS          = 0x00000001<<8
+    Py_TPFLAGS_HAVE_INDEX          = 0x00000001<<17
+    Py_TPFLAGS_HAVE_NEWBUFFER      = 0x00000001<<21
+    Py_TPFLAGS_STRING_SUBCLASS     = 0x00000001<<27
+
+    # Python 3.0+ has only these:
+    Py_TPFLAGS_HEAPTYPE = 0x00000001<<9
+    Py_TPFLAGS_BASETYPE = 0x00000001<<10
+    Py_TPFLAGS_READY    = 0x00000001<<12
+    Py_TPFLAGS_READYING = 0x00000001<<13
+    Py_TPFLAGS_HAVE_GC  = 0x00000001<<14
+    Py_TPFLAGS_HAVE_VERSION_TAG  = 0x00000001<<18
+    Py_TPFLAGS_VALID_VERSION_TAG = 0x00000001<<19
+    Py_TPFLAGS_IS_ABSTRACT    = 0x00000001<<20
+    Py_TPFLAGS_INT_SUBCLASS   = 0x00000001<<23
+    Py_TPFLAGS_LONG_SUBCLASS  = 0x00000001<<24
+    Py_TPFLAGS_LIST_SUBCLASS  = 0x00000001<<25
+    Py_TPFLAGS_TUPLE_SUBCLASS = 0x00000001<<26
+    Py_TPFLAGS_BYTES_SUBCLASS = 0x00000001<<27
+    Py_TPFLAGS_UNICODE_SUBCLASS  = 0x00000001<<28
+    Py_TPFLAGS_DICT_SUBCLASS     = 0x00000001<<29
+    Py_TPFLAGS_BASE_EXC_SUBCLASS = 0x00000001<<30
+    Py_TPFLAGS_TYPE_SUBCLASS     = 0x00000001<<31
+
+    # only use this if we have the stackless extension
+    Py_TPFLAGS_HAVE_STACKLESS_EXTENSION_ = 0x00000003<<15
+
+    class PyMethodDef < FFI::Struct
+      layout ml_name:  :string,
+             ml_meth:  :pointer,
+             ml_flags: :int,
+             ml_doc:   :string   # may be NULL
+
+      def initialize(*args)
+        case args.length
+        when 3, 4
+          name, meth, flags, doc = *args
+          super()
+          self.ml_name = name
+          self[:ml_meth] = meth
+          self[:ml_flags] = flags
+          self.ml_doc = doc
+        else
+          super
+        end
+      end
+
+      def ml_name=(str)
+        @saved_name = FFI::MemoryPointer.from_string(str || '')
+        self.pointer.put_pointer(offset_of(:ml_name), @saved_name)
+      end
+
+      def ml_doc=(str)
+        @saved_doc = FFI::MemoryPointer.from_string(str || '')
+        self.pointer.put_pointer(offset_of(:ml_name), @saved_doc)
+      end
+    end
+
+    # ml_flags should be one of:
+    METH_VARARGS = 0x0001   # args are a tuple of arguments
+    METH_KEYWORDS = 0x0002  # two arguments: the varargs and the kwargs
+    METH_NOARGS = 0x0004    # no arguments (NULL argument pointer)
+    METH_O = 0x0008         # single argument (not wrapped in tuple)
+
+    # not sure when these are needed:
+    METH_CLASS = 0x0010 # for class methods
+    METH_STATIC = 0x0020 # for static methods
+
+    class PyGetSetDef < FFI::Struct
+      layout name:    :string,
+             get:     :pointer,
+             set:     :pointer,  # may be NULL for read-only members
+             doc:     :string,
+             closure: :pointer
+    end
+
+    class PyMemberDef < FFI::Struct
+      layout name:   :string,
+             type:   :int,
+             offset: :ssize_t,
+             flags:  :int,
+             doc:    :string
+
+      [:name, :doc].each do |field|
+        define_method(:"#{field}=") do |str|
+          saved_str = FFI::MemoryPointer.from_string(str)
+          instance_variable_set(:"@saved_#{field}", saved_str)
+          self.pointer.put_pointer(offset_of(field), saved_str)
+        end
+      end
+    end
+
+    class PyTypeObjectStruct < PyObjectStruct
+      layout ob_refcnt: :ssize_t,
+             ob_type:   PyTypeObjectStruct.by_ref,
+             ob_size:   :ssize_t,
+
+             tp_name: :string, # For printing, in format "<module>.<name>"
+
+             # For allocation
+             tp_basicsize: :ssize_t,
+             tp_itemsize: :ssize_t,
+
+             # Methods to implement standard operations
+
+             tp_dealloc: :pointer,
+             tp_print: :pointer,
+             tp_getattr: :pointer,
+             tp_setattr: :pointer,
+             tp_as_async: :pointer, # formerly known as tp_compare (Python 2) or tp_reserved (Python 3)
+             tp_repr: :pointer,
+
+             # Method suites for standard classes
+
+             tp_as_number: :pointer,
+             tp_as_sequence: :pointer,
+             tp_as_mapping: :pointer,
+
+             # More standard operations (here for binary compatibility)
+
+             tp_hash: :pointer,
+             tp_call: :pointer,
+             tp_str: :pointer,
+             tp_getattro: :pointer,
+             tp_setattro: :pointer,
+
+             # Functions to access object as input/output buffer
+             tp_as_buffer: :pointer,
+
+             # Flags to define presence of optional/expanded features
+             tp_flags: :ulong,
+
+             tp_doc: :string, # Documentation string
+
+             # Assigned meaning in release 2.0
+             # call function for all accessible objects
+             tp_traverse: :pointer,
+
+             # delete references to contained objects
+             tp_clear: :pointer,
+
+             # Assigned meaning in release 2.1
+             # rich comparisons
+             tp_richcompare: :pointer,
+
+             # weak reference enabler
+             tp_weaklistoffset: :ssize_t,
+
+             # Iterators
+             tp_iter: :pointer,
+             tp_iternext: :pointer,
+
+             # Attribute descriptor and subclassing stuff
+             tp_methods: PyMethodDef.by_ref,
+             tp_members: PyMemberDef.by_ref,
+             tp_getset: PyGetSetDef.by_ref,
+             tp_base: :pointer,
+             tp_dict: PyObjectStruct.by_ref,
+             tp_descr_get: :pointer,
+             tp_descr_set: :pointer,
+             tp_dictoffset: :ssize_t,
+             tp_init: :pointer,
+             tp_alloc: :pointer,
+             tp_new: :pointer,
+             tp_free: :pointer, # Low-level free-memory routine
+             tp_is_gc: :pointer, # For PyObject_IS_GC
+             tp_bases: PyObjectStruct.by_ref,
+             tp_mro: PyObjectStruct.by_ref, # method resolution order
+             tp_cache: PyObjectStruct.by_ref,
+             tp_subclasses: PyObjectStruct.by_ref,
+             tp_weaklist: PyObjectStruct.by_ref,
+             tp_del: :pointer,
+
+             # Type attribute cache version tag. Added in version 2.6
+             tp_version_tag: :uint,
+
+             tp_finalize: :pointer,
+
+             # The following members are only used for COUNT_ALLOCS builds of Python
+             tp_allocs: :ssize_t,
+             tp_frees: :ssize_t,
+             tp_maxalloc: :ssize_t,
+             tp_prev: :pointer,
+             tp_next: :pointer
+
+      def self.new(*args)
+        case args.length
+        when 0, 1
+          super
+        else
+          name, basic_size = *args
+          new.tap do |t|
+            # NOTE: Disable autorelease for avoiding SEGV occurrance in Python's GC collect function
+            #       at which the __new__ method object of this type object is freed.
+            t.pointer.autorelease = false
+
+            # PyVarObject_HEAD_INIT(&PyType_Type, 0)
+            t[:ob_refcnt] = 1
+            t[:ob_type] = LibPython.PyType_Type
+            t[:ob_size] = 0
+
+            t[:tp_basicsize] = basic_size
+            stackless_extension_flag = PyCall.has_stackless_extension ? Py_TPFLAGS_HAVE_STACKLESS_EXTENSION_ : 0
+            t[:tp_flags] = if PYTHON_VERSION >= '3'
+                             stackless_extension_flag | Py_TPFLAGS_HAVE_VERSION_TAG
+                           else
+                             Py_TPFLAGS_HAVE_GETCHARBUFFER |
+                               Py_TPFLAGS_HAVE_SEQUENCE_IN |
+                               Py_TPFLAGS_HAVE_INPLACEOPS |
+                               Py_TPFLAGS_HAVE_RICHCOMPARE |
+                               Py_TPFLAGS_HAVE_WEAKREFS |
+                               Py_TPFLAGS_HAVE_ITER |
+                               Py_TPFLAGS_HAVE_CLASS |
+                               stackless_extension_flag |
+                               Py_TPFLAGS_HAVE_INDEX
+                           end
+            t.tp_name = name
+            yield t if block_given?
+            t[:tp_new] = LibPython.find_symbol(:PyType_GenericNew) if t[:tp_new] == FFI::Pointer::NULL
+            raise PyError.fetch if LibPython.PyType_Ready(t) < 0
+            LibPython.Py_IncRef(t)
+          end
+        end
+      end
+
+      def tp_name=(str)
+        @saved_name = FFI::MemoryPointer.from_string(str)
+        self.pointer.put_pointer(offset_of(:tp_name), @saved_name)
+      end
+    end
+  end
+end

data/lib/pycall/libpython.rb

@@ -1,28 +1,11 @@
 require 'ffi'
+require 'pycall/libpython/pyobject_struct'
+require 'pycall/libpython/pytypeobject_struct'
 
 module PyCall
   module LibPython
     extend FFI::Library
 
-    class PyObjectStruct < FFI::Struct
-      layout ob_refcnt: :ssize_t,
-             ob_type:   PyObjectStruct.by_ref
-
-      def self.null
-        new(FFI::Pointer::NULL)
-      end
-
-      def py_none?
-        PyCall.none?(self)
-      end
-
-      def kind_of?(klass)
-        klass = klass.__pyobj__ if klass.kind_of? PyObjectWrapper
-        return super unless klass.kind_of? PyObjectStruct
-        PyCall::Types.pyisinstance(self, klass)
-      end
-    end
-
     private_class_method
 
     def self.find_libpython(python = nil)
@@ -151,6 +134,8 @@ module PyCall
     ffi_lib_flags :lazy, :global
     libpython = find_libpython ENV['PYTHON']
 
+    define_singleton_method(:find_symbol) {|name| libpython.find_symbol(name.to_s) }
+
     attach_function :Py_GetVersion, [], :string
     PYTHON_DESCRIPTION = LibPython.Py_GetVersion().freeze
     PYTHON_VERSION = PYTHON_DESCRIPTION.split(' ', 2)[0].freeze
@@ -171,37 +156,42 @@ module PyCall
       _Py_NoneStruct
     end
 
-    attach_variable :PyType_Type, PyObjectStruct
+    attach_variable :PyType_Type, PyTypeObjectStruct
 
     if libpython.find_variable('PyInt_Type')
       has_PyInt_Type = true
-      attach_variable :PyInt_Type, PyObjectStruct
+      attach_variable :PyInt_Type, PyTypeObjectStruct
     else
       has_PyInt_Type = false
-      attach_variable :PyInt_Type, :PyLong_Type, PyObjectStruct
+      attach_variable :PyInt_Type, :PyLong_Type, PyTypeObjectStruct
     end
 
-    attach_variable :PyLong_Type, PyObjectStruct
-    attach_variable :PyBool_Type, PyObjectStruct
-    attach_variable :PyFloat_Type, PyObjectStruct
-    attach_variable :PyComplex_Type, PyObjectStruct
-    attach_variable :PyUnicode_Type, PyObjectStruct
+    attach_variable :PyLong_Type, PyTypeObjectStruct
+    attach_variable :PyBool_Type, PyTypeObjectStruct
+    attach_variable :PyFloat_Type, PyTypeObjectStruct
+    attach_variable :PyComplex_Type, PyTypeObjectStruct
+    attach_variable :PyUnicode_Type, PyTypeObjectStruct
 
     if libpython.find_symbol('PyString_FromStringAndSize')
       string_as_bytes = false
-      attach_variable :PyString_Type, PyObjectStruct
+      attach_variable :PyString_Type, PyTypeObjectStruct
     else
       string_as_bytes = true
-      attach_variable :PyString_Type, :PyBytes_Type, PyObjectStruct
+      attach_variable :PyString_Type, :PyBytes_Type, PyTypeObjectStruct
     end
 
-    attach_variable :PyList_Type, PyObjectStruct
-    attach_variable :PyTuple_Type, PyObjectStruct
-    attach_variable :PyDict_Type, PyObjectStruct
-    attach_variable :PySet_Type, PyObjectStruct
+    attach_variable :PyList_Type, PyTypeObjectStruct
+    attach_variable :PyTuple_Type, PyTypeObjectStruct
+    attach_variable :PyDict_Type, PyTypeObjectStruct
+    attach_variable :PySet_Type, PyTypeObjectStruct
 
-    attach_variable :PyFunction_Type, PyObjectStruct
-    attach_variable :PyMethod_Type, PyObjectStruct
+    attach_variable :PyFunction_Type, PyTypeObjectStruct
+    attach_variable :PyMethod_Type, PyTypeObjectStruct
+
+    # --- exceptions ---
+
+    attach_variable :PyExc_RuntimeError, PyObjectStruct.ptr
+    attach_variable :PyExc_TypeError, PyObjectStruct.ptr
 
     # --- functions ---
 
@@ -216,6 +206,7 @@ module PyCall
 
     # Object
 
+    attach_function :_PyObject_New, [PyTypeObjectStruct.ptr], PyObjectStruct.ptr
     attach_function :PyObject_RichCompare, [PyObjectStruct.by_ref, PyObjectStruct.by_ref, :int], PyObjectStruct.by_ref
     attach_function :PyObject_GetAttrString, [PyObjectStruct.by_ref, :string], PyObjectStruct.by_ref
     attach_function :PyObject_SetAttrString, [PyObjectStruct.by_ref, :string, PyObjectStruct.by_ref], :int
@@ -231,6 +222,10 @@ module PyCall
     attach_function :PyObject_Type, [PyObjectStruct.by_ref], PyObjectStruct.by_ref
     attach_function :PyCallable_Check, [PyObjectStruct.by_ref], :int
 
+    # Type
+
+    attach_function :PyType_Ready, [PyTypeObjectStruct.ptr], :int
+
     # Bool
 
     attach_function :PyBool_FromLong, [:long], PyObjectStruct.by_ref
@@ -339,13 +334,23 @@ module PyCall
     attach_function :PySet_Size, [PyObjectStruct.by_ref], :ssize_t
     attach_function :PySet_Contains, [PyObjectStruct.by_ref, PyObjectStruct.by_ref], :int
 
+    # Method
+
+    attach_function :PyCFunction_NewEx, [PyMethodDef.ptr, :pointer, :pointer], PyObjectStruct.ptr
+
+    # Weakref
+
+    attach_function :PyWeakref_NewRef, [PyObjectStruct.ptr, PyObjectStruct.ptr], PyObjectStruct.ptr
+
     # Module
 
     attach_function :PyModule_GetDict, [PyObjectStruct.by_ref], PyObjectStruct.by_ref
 
     # Import
 
+    attach_function :PyImport_GetModuleDict, [], PyObjectStruct.by_ref
     attach_function :PyImport_ImportModule, [:string], PyObjectStruct.by_ref
+    attach_function :PyImport_ImportModuleLevel, [:string, PyObjectStruct.by_ref, PyObjectStruct.by_ref, PyObjectStruct.by_ref, :int], PyObjectStruct.by_ref
 
     # Operators
 
@@ -367,6 +372,7 @@ module PyCall
     attach_function :PyErr_Occurred, [], PyObjectStruct.by_ref
     attach_function :PyErr_Fetch, [:pointer, :pointer, :pointer], :void
     attach_function :PyErr_NormalizeException, [:pointer, :pointer, :pointer], :void
+    attach_function :PyErr_SetString, [PyObjectStruct.ptr, :string], :void
 
     public_class_method
   end

data/lib/pycall/list.rb

@@ -32,6 +32,8 @@ module PyCall
       LibPython.PyList_Size(__pyobj__)
     end
 
+    alias length size
+
     def include?(value)
       value = Conversions.from_ruby(value)
       value = LibPython.PySequence_Contains(__pyobj__, value)

data/lib/pycall/pyobject_wrapper.rb

@@ -1,4 +1,6 @@
 module PyCall
+  HASH_SALT = "PyCall::PyObject".hash
+
   Py_LT = 0
   Py_LE = 1
   Py_EQ = 2

data/lib/pycall/ruby_wrapper.rb

@@ -0,0 +1,137 @@
+require 'pycall'
+
+module PyCall
+  class RubyWrapStruct < LibPython::PyObjectStruct
+      layout ob_refcnt:    :ssize_t,
+             ob_type:      LibPython::PyTypeObjectStruct.by_ref,
+             rb_object_id: :ssize_t
+  end
+
+  # This will be called from __initialize_pycall__ defined in pycall/init.rb
+  private_class_method def self.__initialize_ruby_wrapper__()
+    @ruby_wrapper_members = FFI::MemoryPointer.new(LibPython::PyMemberDef.size, 2)
+    LibPython::PyMemberDef.new(@ruby_wrapper_members).tap do |member|
+      member.name     = 'rb_object_id'
+      member[:type]   = LibPython::T_PYSSIZET
+      member[:offset] = LibPython::PyObjectStruct.size
+      member[:flags]  = RubyWrapStruct.offset_of(:rb_object_id)
+      member.doc      = "Ruby object ID"
+    end
+    @ruby_wrapper_dealloc = FFI::Function.new(:void, [LibPython::PyObjectStruct.ptr]) do |pyptr|
+      GCGuard.unregister(pyptr)
+      nil
+    end
+    @ruby_wrapper_repr = FFI::Function.new(LibPython::PyObjectStruct.ptr, [LibPython::PyObjectStruct.ptr]) do |pyptr|
+      str = if pyptr.null?
+              '<PyCall.ruby_wrapper NULL>'
+            else
+              obj = ObjectSpace._id2ref(RubyWrapStruct.new(pyptr.pointer)[:rb_object_id])
+              "<PyCall.ruby_wrapper #{obj.inspect}>"
+            end
+      Conversions.from_ruby(str)
+    end
+    @ruby_wrapper_hash = FFI::Function.new(:uint64, [LibPython::PyObjectStruct.ptr]) do |pyptr|
+      h = ObjectSpace._id2ref(RubyWrapStruct.new(pyptr.pointer)[:rb_object_id]).hash
+      h == -1 ? PyCall::HASH_SALT : h
+    end
+    pysalt32 = 0xb592cd9b # This value comes from PyCall.jl
+    @ruby_wrapper_hash32 = FFI::Function.new(:uint32, [LibPython::PyObjectStruct.ptr]) do |pyptr|
+      # int64to32hash from src/support/hashing.c in julia
+      key = ObjectSpace._id2ref(RubyWrapStruct.new(pyptr.pointer)[:rb_object_id]).hash
+      key = (~key) + (key << 18)
+      key =   key  ^ (key >> 31)
+      key = key * 21
+      key = key ^ (key >> 11)
+      key = key + (key << 6)
+      key = key ^ (key >> 22)
+      h = 0xFFFFFFFF & key
+      h == -1 ? pysalt32 : h
+    end
+    @ruby_callable_call = FFI::Function.new(
+      LibPython::PyObjectStruct.ptr,
+      [LibPython::PyObjectStruct.ptr, LibPython::PyObjectStruct.ptr, LibPython::PyObjectStruct.ptr]
+    ) do |self_, args_, kwargs_|
+      obj = ObjectSpace._id2ref(RubyWrapStruct.new(self_.pointer)[:rb_object_id])
+      begin
+        args = Conversions.to_ruby(args_).to_ary
+        if kwargs_.null?
+          ret = obj.(*args)
+        else
+          kwargs = PyCall::Dict.new(kwargs_).to_hash
+          ret = obj.(*args, **kwargs)
+        end
+        Conversions.from_ruby(ret)
+      rescue Exception => err
+        PyCall.raise_python_exception(err)
+        LibPython::PyObjectStruct.null
+      end
+    end
+    @ruby_callable_getattr = FFI::Function.new(
+      LibPython::PyObjectStruct.ptr,
+      [LibPython::PyObjectStruct.ptr, LibPython::PyObjectStruct.ptr]
+    ) do |self_, attr_|
+      obj = ObjectSpace._id2ref(RubyWrapStruct.new(self_.pointer)[:rb_object_id])
+      attr = Conversions.to_ruby(attr_)
+      begin
+        case attr
+        when '__name__', 'func_name'
+          if obj.respond_to? :name
+            Conversions.from_ruby(obj.name)
+          else
+            Conversions.from_ruby(obj.to_s)
+          end
+        when '__doc__', 'func_doc'
+          # TODO: support docstring
+          PyCall.none
+        when '__module__', '__defaults__', 'func_defaults', '__closure__', 'func_closure'
+          PyCall.none
+        else
+          # TODO: handle __code__ and func_code
+          LibPython.PyObject_GenericGetAttr(self_, attr_)
+        end
+      rescue Exception => err
+        PyCall.raise_python_exception(err)
+        LibPython::PyObjectStruct.null
+      end
+    end
+    @ruby_wrapper = LibPython::PyTypeObjectStruct.new("PyCall.ruby_wrapper", RubyWrapStruct.size) do |t|
+      t[:tp_flags] |= LibPython::Py_TPFLAGS_BASETYPE
+      t[:tp_members] = LibPython::PyMemberDef.new(@ruby_wrapper_members)
+      t[:tp_dealloc] = @ruby_wrapper_dealloc
+      t[:tp_repr] = @ruby_wrapper_repr
+      if FFI.type_size(LibPython.find_type(:Py_hash_t)) < FFI.type_size(:uint64)
+        t[:tp_hash] = @ruby_wrapper_hash32
+      else
+        t[:tp_hash] = @ruby_wrapper_hash
+      end
+    end
+    @ruby_callable = PyCall.ruby_wrapper_subclass_new("PyCall.ruby_callable") do |t|
+      t[:tp_call] = @ruby_callable_call
+      t[:tp_getattro] = @ruby_callable_getattr
+    end
+  end
+
+  def self.ruby_wrapper_subclass_new(name)
+    LibPython::PyTypeObjectStruct.new(name, RubyWrapStruct.size + FFI.type_size(:pointer)) do |t|
+      t[:tp_base] = @ruby_wrapper.pointer
+      LibPython.Py_IncRef(LibPython::PyObjectStruct.new(@ruby_wrapper.pointer))
+      yield(t)
+    end
+  end
+
+  def self.ruby_wrapper_new(type, obj)
+    pyobj = LibPython._PyObject_New(type)
+    RubyWrapStruct.new(pyobj.pointer).tap do |rw|
+      rw[:rb_object_id] = obj.object_id
+      GCGuard.register(rw, obj)
+    end
+  end
+
+  def self.wrap_ruby_object(obj)
+    ruby_wrapper_new(@ruby_wrapper, obj)
+  end
+
+  def self.wrap_ruby_callable(obj)
+    ruby_wrapper_new(@ruby_callable, obj)
+  end
+end

data/lib/pycall/set.rb

@@ -6,10 +6,12 @@ module PyCall
       super(pyobj)
     end
 
-    def length
+    def size
       LibPython.PySet_Size(__pyobj__)
     end
 
+    alias length size
+
     def include?(obj)
       1 == LibPython.PySet_Contains(__pyobj__, Conversions.from_ruby(obj))
     end

data/lib/pycall/tuple.rb

@@ -22,10 +22,12 @@ module PyCall
       new(ary)
     end
 
-    def length
+    def size
       LibPython.PyTuple_Size(__pyobj__)
     end
 
+    alias length size
+
     def [](index)
       LibPython.PyTuple_GetItem(__pyobj__, index).to_ruby
     end

data/lib/pycall/version.rb

@@ -1,3 +1,3 @@
 module PyCall
-  VERSION = "0.1.0.alpha.20170502"
+  VERSION = "0.1.0.alpha.20170711"
 end

data/lib/pycall.rb

@@ -1,5 +1,7 @@
 require "pycall/version"
 require "pycall/libpython"
+require "pycall/gc_guard"
+require "pycall/exception"
 require "pycall/pyobject_wrapper"
 require "pycall/pyobject"
 require "pycall/pyerror"
@@ -13,4 +15,5 @@ require "pycall/dict"
 require "pycall/set"
 require "pycall/slice"
 require "pycall/utils"
+require "pycall/ruby_wrapper"
 require "pycall/init"

data/pycall.gemspec

@@ -34,4 +34,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "launchy"
+  spec.add_development_dependency "pry"
 end

data/tasks/docker.rake

@@ -5,6 +5,7 @@ namespace :docker do
     end
   end
 
+  desc 'Run docker container [port=8888] [attach_local=$(pwd)]'
   task :run do
     require 'securerandom'
     require 'launchy'