pybind 0.1.0

data/lib/pybind/python/investigator.py

@@ -0,0 +1,10 @@
+from distutils.sysconfig import get_config_var
+import sys
+
+print('EXECUTABLE: ' + str(sys.executable))
+print('EXECPREFIX: ' + str(sys.exec_prefix))
+print('PREFIX: ' + str(sys.prefix))
+if sys.version_info >= (3, 3):
+    print('IMPLEMENTATIONMULTIARCH: ' + str(sys.implementation._multiarch))
+for var in ('VERSION', 'INSTSONAME', 'LIBRARY', 'LDLIBRARY', 'LIBDIR', 'PYTHONFRAMEWORKPREFIX', 'MULTIARCH'):
+  print(var + ': ' + str(get_config_var(var)))

data/lib/pybind/struct.rb

@@ -0,0 +1,36 @@
+require 'ffi'
+
+module PyBind
+  class PyObjectStruct < FFI::Struct
+    layout ob_refcnt: :ssize_t,
+           ob_type:   PyObjectStruct.by_ref
+
+    def self.null
+      new(FFI::Pointer::NULL)
+    end
+
+    def none?
+      PyBind.None.to_ptr == to_ptr
+    end
+
+    def kind_of?(klass)
+      case klass
+      when PyBind::PyObjectStruct
+        value = LibPython.PyObject_IsInstance(self, klass)
+        raise PyError.fetch if value == -1
+        value == 1
+      else
+        super
+      end
+    end
+
+    def to_ruby_object
+      PyObject.new(self)
+    end
+
+    def to_python_struct
+      self
+    end
+    alias_method :to_python, :to_python_struct
+  end
+end

data/lib/pybind/typecast.rb

@@ -0,0 +1,28 @@
+module PyBind
+  module TypeCast
+    def self.from_python(pyobj)
+      pystruct = pyobj.to_python_struct
+      return nil if pystruct.null? || pystruct.none?
+
+      Types.pytypes.each do |pytype|
+        return pytype.from_python(pystruct) if pytype.python_instance?(pystruct)
+      end
+      PyObject.from_python(pystruct)
+    end
+
+    def self.to_python_arguments(indices)
+      if indices.length == 1
+        indices = indices[0]
+      else
+        indices = PyTuple.new(indices)
+      end
+      indices.to_python
+    end
+  end
+
+  class PyObjectStruct
+    def to_ruby
+      TypeCast.from_python(self)
+    end
+  end
+end

data/lib/pybind/types.rb

@@ -0,0 +1,21 @@
+module PyBind
+  module Types
+    class << self
+      attr_reader :pytypes
+    end
+
+    @pytypes ||= []
+    def self.register_type(pytype)
+      @pytypes.unshift(pytype)
+    end
+  end
+end
+
+require 'pybind/core_ext/basic'
+require 'pybind/types/basic'
+require 'pybind/types/object'
+require 'pybind/types/tuple'
+require 'pybind/types/slice'
+require 'pybind/types/list'
+require 'pybind/types/dict'
+require 'pybind/types/set'

data/lib/pybind/types/basic.rb

@@ -0,0 +1,70 @@
+module PyBind
+  class PyType
+    include PyObjectWrapper
+    pybind_type LibPython.PyType_Type
+
+    def to_s
+      return super unless has_attribute?('__name__')
+      get_attribute('__name__')
+    end
+  end
+
+  class PyString
+    include PyObjectWrapper
+
+    pybind_type LibPython.PyString_Type do |pystruct|
+      FFI::MemoryPointer.new(:string) do |str_ptr|
+        FFI::MemoryPointer.new(:int) do |len_ptr|
+          res = LibPython.PyString_AsStringAndSize(pystruct, 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
+  end
+
+  class PyUnicode
+    include PyObjectWrapper
+
+    pybind_type LibPython.PyUnicode_Type do |pystruct|
+      pystruct = LibPython.PyUnicode_AsUTF8String(pystruct)
+      PyString.from_python(pystruct).force_encoding(Encoding::UTF_8)
+    end
+  end
+
+  class PyInt
+    include PyObjectWrapper
+
+    pybind_type LibPython.PyInt_Type do |pystruct|
+      LibPython.PyInt_AsSsize_t(pystruct)
+    end
+  end
+
+  class PyBool
+    include PyObjectWrapper
+
+    pybind_type LibPython.PyBool_Type do |pystruct|
+      LibPython.PyInt_AsSsize_t(pystruct) != 0
+    end
+  end
+
+  class PyFloat
+    include PyObjectWrapper
+
+    pybind_type LibPython.PyFloat_Type do |pystruct|
+      LibPython.PyFloat_AsDouble(pystruct)
+    end
+  end
+
+  class PyComplex
+    include PyObjectWrapper
+
+    pybind_type LibPython.PyComplex_Type do |pystruct|
+      real = LibPython.PyComplex_RealAsDouble(pystruct)
+      imag = LibPython.PyComplex_ImagAsDouble(pystruct)
+      Complex(real, imag)
+    end
+  end
+end

data/lib/pybind/types/dict.rb

@@ -0,0 +1,94 @@
+module PyBind
+  class PyDict
+    include Enumerable
+    include PyObjectWrapper
+    pybind_type LibPython.PyDict_Type
+
+    def self.new(init = nil)
+      case init
+      when PyObjectStruct
+        super
+      when nil
+        new(LibPython.PyDict_New())
+      when Hash
+        new.tap do |dict|
+          init.each do |key, value|
+            dict[key] = value
+          end
+        end
+      else
+        raise TypeError, "the argument must be a PyObjectStruct or a Hash"
+      end
+    end
+
+    def [](key)
+      case key
+      when String, Symbol
+        LibPython.PyDict_GetItemString(@pystruct, key.to_s).to_ruby
+      else
+        key = key.to_python
+        LibPython.PyDict_GetItem(@pystruct, key).to_ruby
+      end
+    end
+
+    def []=(key, value)
+      value = value.to_python
+      case key
+      when String, Symbol
+        LibPython.PyDict_SetItemString(@pystruct, key.to_s, value)
+      else
+        key = key.to_python
+        LibPython.PyDict_SetItem(@pystruct, key, value)
+      end
+      value
+    end
+
+    def delete(key)
+      case key
+      when String, Symbol
+        value = LibPython.PyDict_GetItemString(@pystruct, key).to_ruby
+        LibPython.PyDict_DelItemString(@pystruct, key.to_s)
+      else
+        key = key.to_python
+        value = LibPython.PyDict_GetItem(@pystruct, key).to_ruby
+        LibPython.PyDict_DelItem(@pystruct, key)
+      end
+      value
+    end
+
+    def size
+      LibPython.PyDict_Size(@pystruct)
+    end
+
+    def keys
+      LibPython.PyDict_Keys(@pystruct).to_ruby
+    end
+
+    def values
+      LibPython.PyDict_Values(@pystruct).to_ruby
+    end
+
+    def has_key?(key)
+      key = key.to_python
+      value = LibPython.PyDict_Contains(@pystruct, key)
+      raise PyError.fetch if value == -1
+      value == 1
+    end
+
+    def to_a
+      LibPython.PyDict_Items(@pystruct).to_ruby
+    end
+
+    def to_hash
+      Hash[to_a]
+    end
+
+    def each
+      return enum_for unless block_given?
+      keys.each do |key|
+        yield key, self[key]
+      end
+      self
+    end
+  end
+end

data/lib/pybind/types/function.rb

@@ -0,0 +1,26 @@
+module PyBind
+  module PyCallable
+  end
+
+  class PyFunction
+    include PyCallable
+    include PyObjectWrapper
+    pybind_type PyBind.types.FunctionType
+  end
+
+  class PyMethod
+    include PyCallable
+    include PyObjectWrapper
+    pybind_type PyBind.types.MethodType
+  end
+
+  class PyBuiltinFunction
+    include PyCallable
+    include PyObjectWrapper
+    pybind_type PyBind.types.BuiltinFunctionType
+  end
+
+  class PyType
+    include PyCallable
+  end
+end

data/lib/pybind/types/list.rb

@@ -0,0 +1,39 @@
+require 'pybind/types/sequence'
+
+module PyBind
+  class PyList
+    include PyObjectWrapper
+    pybind_type LibPython.PyList_Type
+
+    include PySequence
+
+    def self.new(init = nil)
+      case init
+      when PyObjectStruct
+        super
+      when nil
+        new(0)
+      when Integer
+        new(LibPython.PyList_New(init))
+      when Array
+        new.tap do |list|
+          init.each do |item|
+            list << item
+          end
+        end
+      else
+        raise TypeError, "the argument must be an Integer, a PyObjectStruct or a Array"
+      end
+    end
+
+    def <<(value)
+      value = value.to_python
+      LibPython.PyList_Append(@pystruct, value)
+      self
+    end
+
+    def size
+      LibPython.PyList_Size(@pystruct)
+    end
+  end
+end

data/lib/pybind/types/object.rb

@@ -0,0 +1,9 @@
+module PyBind
+  class PyObject
+    include PyObjectWrapper
+
+    def self.null
+      new(PyObjectStruct.null)
+    end
+  end
+end

data/lib/pybind/types/sequence.rb

@@ -0,0 +1,26 @@
+module PyBind
+  module PySequence
+    include Enumerable
+
+    def include?(value)
+      value = value.to_python
+      value = LibPython.PySequence_Contains(@pystruct, value)
+      raise PyError.fetch if value == -1
+      value == 1
+    end
+
+    def each
+      return enum_for unless block_given?
+      size.times do |i|
+        yield self[i]
+      end
+      self
+    end
+
+    def to_a
+      each.to_a
+    end
+
+    alias_method :to_ary, :to_a
+  end
+end

data/lib/pybind/types/set.rb

@@ -0,0 +1,19 @@
+module PyBind
+  class PySet
+    include PyObjectWrapper
+    pybind_type LibPython.PySet_Type
+
+    def initialize(init)
+      super
+    end
+
+    def size
+      LibPython.PySet_Size(@pystruct)
+    end
+
+    def include?(obj)
+      obj = obj.to_python
+      LibPython.PySet_Contains(@pystruct, obj) == 1
+    end
+  end
+end

data/lib/pybind/types/slice.rb

@@ -0,0 +1,19 @@
+module PyBind
+  class PySlice
+    include PyObjectWrapper
+    pybind_type LibPython.PySlice_Type
+
+    def self.new(start, stop = nil, step = nil)
+      if stop.nil? && step.nil?
+        start, stop = nil, start
+        return super(stop) if stop.kind_of?(PyObjectStruct)
+      end
+      start = start ? start.to_python : PyObjectStruct.null
+      stop = stop ? stop.to_python : PyObjectStruct.null
+      step = step ? step.to_python : PyObjectStruct.null
+      pyobj = LibPython.PySlice_New(start, stop, step)
+      raise PyError.fetch if pyobj.null?
+      pyobj.to_ruby
+    end
+  end
+end

data/lib/pybind/types/tuple.rb

@@ -0,0 +1,45 @@
+require 'pybind/types/sequence'
+
+module PyBind
+  class PyTuple
+    include PyObjectWrapper
+    pybind_type LibPython.PyTuple_Type
+
+    include PySequence
+
+    def self.new(init)
+      case init
+      when PyObjectStruct
+        super
+      when Integer
+        super(LibPython.PyTuple_New(init))
+      when Array
+        tuple = new(init.size)
+        init.each_with_index do |obj, index|
+          tuple[index] = obj
+        end
+        tuple
+      else
+        raise TypeError, "the argument must be an Integer, a PyObjectStruct or a Array"
+      end
+    end
+
+    # Make tuple from array
+    def self.[](*ary)
+      new(ary)
+    end
+
+    def size
+      LibPython.PyTuple_Size(@pystruct)
+    end
+
+    def [](index)
+      LibPython.PyTuple_GetItem(@pystruct, index).to_ruby
+    end
+
+    def []=(index, value)
+      value = value.to_python
+      LibPython.PyTuple_SetItem(@pystruct, index, value)
+    end
+  end
+end