pycall 0.1.0.alpha → 0.1.0.alpha.20170224

data/lib/pycall/list.rb

@@ -0,0 +1,65 @@
+module PyCall
+  class List
+    include PyObjectWrapper
+
+    def self.new(init=nil)
+      case init
+      when PyObject
+        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
+        new(obj.to_ary)
+      end
+    end
+
+    def initialize(pyobj)
+      super(pyobj, LibPython.PyList_Type)
+    end
+
+    def [](index)
+      LibPython.PyList_GetItem(__pyobj__, index).to_ruby
+    end
+
+    def []=(index, value)
+      value = Conversions.from_ruby(value)
+      LibPython.PyList_SetItem(__pyobj__, index, value)
+      value
+    end
+
+    def <<(value)
+      value = Conversions.from_ruby(value)
+      LibPython.PyList_Append(__pyobj__, value)
+      self
+    end
+
+    def size
+      LibPython.PyList_Size(__pyobj__)
+    end
+
+    def include?(value)
+      value = Conversions.from_ruby(value)
+      LibPython.PyList_Contains(__pyobj__, value).to_ruby
+    end
+
+    def to_a
+      [].tap do |a|
+        i, n = 0, size
+        while i < n
+          a << self[i]
+          i += 1
+        end
+      end
+    end
+
+    alias to_ary to_a
+  end
+end

data/lib/pycall/pyerror.rb

@@ -0,0 +1,25 @@
+module PyCall
+  class PyError < StandardError
+    def self.fetch
+      ptrs = FFI::MemoryPointer.new(:pointer, 3)
+      ptype      = ptrs + 0 * ptrs.type_size
+      pvalue     = ptrs + 1 * ptrs.type_size
+      ptraceback = ptrs + 2 * ptrs.type_size
+      LibPython.PyErr_Fetch(ptype, pvalue, ptraceback)
+      LibPython.PyErr_NormalizeException(ptype, pvalue, ptraceback)
+      type = PyTypeObject.new(ptype.read(:pointer))
+      value = PyObject.new(pvalue.read(:pointer))
+      traceback = PyObject.new(ptraceback.read(:pointer))
+      new(type, value, traceback)
+    end
+
+    def initialize(type, value, traceback)
+      @type = type
+      @value = value
+      @traceback = traceback
+      super("#{@type.inspect}: #{PyCall.eval('str').(@value)}")
+    end
+
+    attr_reader :type, :value, :traceback
+  end
+end

data/lib/pycall/pyobject.rb

@@ -0,0 +1,185 @@
+module PyCall
+  Py_LT = 0
+  Py_LE = 1
+  Py_EQ = 2
+  Py_NE = 3
+  Py_GT = 4
+  Py_GE = 5
+
+  RICH_COMPARISON_OPCODES = {
+    :<  => Py_LT,
+    :<= => Py_LE,
+    :== => Py_EQ,
+    :!= => Py_NE,
+    :>  => Py_GT,
+    :>= => Py_GE
+  }.freeze
+
+  module PyObjectMethods
+    def rich_compare(other, op)
+      opcode = RICH_COMPARISON_OPCODES[op]
+      raise ArgumentError, "Unknown comparison op: #{op}" unless opcode
+
+      other = Conversions.from_ruby(other) unless other.kind_of?(PyObject)
+      return other.null? if self.null?
+      return false if other.null?
+
+      value = LibPython.PyObject_RichCompare(self, other, opcode)
+      raise "Unable to compare: #{self} #{op} #{other}" if value.null?
+      value.to_ruby
+    end
+
+    RICH_COMPARISON_OPCODES.keys.each do |op|
+      define_method(op) {|other| rich_compare(other, op) }
+    end
+
+    def py_none?
+      to_ptr == LibPython.Py_None.to_ptr
+    end
+
+    def kind_of?(klass)
+      case klass
+      when PyTypeObject
+        Types.pyisinstance(self, klass)
+      else
+        super
+      end
+    end
+  end
+
+  class PyObject < FFI::Struct
+    include PyObjectMethods
+
+    def self.null
+      new(FFI::Pointer::NULL)
+    end
+
+    alias __aref__ []
+    alias __aset__ []=
+
+    def [](*indices)
+      if indices.length == 1
+        indices = indices[0]
+      else
+        indices = PyCall.tuple(*indices)
+      end
+      PyCall.getitem(self, indices)
+    end
+
+    def []=(*indices_and_value)
+      value = indices_and_value.pop
+      indices = indices_and_value
+      if indices.length == 1
+        indices = indices[0]
+      else
+        indices = PyCall.tuple(*indices)
+      end
+      PyCall.setitem(self, indices, value)
+    end
+
+    def +(other)
+      value = LibPython.PyNumber_Add(self, other)
+      return value.to_ruby unless value.null?
+      raise PyError.fetch
+    end
+
+    def -(other)
+      value = LibPython.PyNumber_Subtract(self, other)
+      return value.to_ruby unless value.null?
+      raise PyError.fetch
+    end
+
+    def *(other)
+      value = LibPython.PyNumber_Multiply(self, other)
+      return value.to_ruby unless value.null?
+      raise PyError.fetch
+    end
+
+    def /(other)
+      value = LibPython.PyNumber_TrueDivide(self, other)
+      return value.to_ruby unless value.null?
+      raise PyError.fetch
+    end
+
+    def coerce(other)
+      [Conversions.from_ruby(other), self]
+    end
+
+    def call(*args, **kwargs)
+      args = PyCall::Tuple[*args]
+      kwargs = kwargs.empty? ? PyObject.null : PyCall::Dict.new(kwargs).__pyobj__
+      res = LibPython.PyObject_Call(self, args.__pyobj__, kwargs)
+      return res.to_ruby if LibPython.PyErr_Occurred().null?
+      raise PyError.fetch
+    end
+
+    def method_missing(name, *args, **kwargs)
+      if PyCall.hasattr?(self, name)
+        PyCall.getattr(self, name)
+      else
+        super
+      end
+    end
+
+    def to_s
+      PyCall.str(self)
+    end
+
+    alias inspect to_s
+  end
+
+  class PyTypeObject < FFI::Struct
+    include PyObjectMethods
+
+    def ===(obj)
+      obj.kind_of? self
+    end
+
+    def inspect
+      "pytype(#{self[:tp_name]})"
+    end
+  end
+
+  def self.getattr(pyobj, name, default=nil)
+    name = check_attr_name(name)
+    value = LibPython.PyObject_GetAttrString(pyobj, name)
+    if value.null?
+      return default if default
+      raise PyError.fetch
+    end
+    value.to_ruby
+  end
+
+  def self.setattr(pyobj, name, value)
+    name = check_attr_name(name)
+    value = Conversions.from_ruby(value)
+    return self unless LibPython.PyObject_SetAttrString(pyobj, name, value) == -1
+    raise PyError.fetch
+  end
+
+  def self.hasattr?(pyobj, name)
+    name = check_attr_name(name)
+    1 == LibPython.PyObject_HasAttrString(pyobj, name)
+  end
+
+  def self.check_attr_name(name)
+    return name.to_str if name.respond_to? :to_str
+    return name.to_s if name.kind_of? Symbol
+    raise TypeError, "attribute name must be a String or a Symbol: #{name.inspect}"
+  end
+  private_class_method :check_attr_name
+
+  def self.getitem(pyobj, key)
+    pykey = Conversions.from_ruby(key)
+    value = LibPython.PyObject_GetItem(pyobj, pykey)
+    return value.to_ruby unless value.null?
+    raise PyError.fetch
+  end
+
+  def self.setitem(pyobj, key, value)
+    pykey = Conversions.from_ruby(key)
+    value = Conversions.from_ruby(value)
+    return self unless LibPython.PyObject_SetItem(pyobj, pykey, value) == -1
+    raise PyError.fetch
+  end
+end

data/lib/pycall/pyobject_wrapper.rb

@@ -0,0 +1,48 @@
+module PyCall
+  module PyObjectWrapper
+    def initialize(pyobj, pytype)
+      check_type pyobj, pytype
+      @__pyobj__ = pyobj
+    end
+
+    attr_reader :__pyobj__
+
+    def ==(other)
+      case other
+      when self.class
+        __pyobj__ == other.__pyobj__
+      when PyObject
+        __pyobj__ == other
+      else
+        super
+      end
+    end
+
+    def call(*args, **kwargs)
+      __pyobj__.call(*args, **kwargs)
+    end
+
+    def method_missing(name, *args, **kwargs)
+      if PyCall.hasattr?(__pyobj__, name.to_s)
+        PyCall.getattr(__pyobj__, name)
+      else
+        super
+      end
+    end
+
+    def to_s
+      __pyobj__.to_s
+    end
+
+    def inspect
+      __pyobj__.inspect
+    end
+
+    private
+
+    def check_type(pyobj, pytype)
+      return if pyobj.kind_of?(PyObject) && pyobj.kind_of?(pytype)
+      raise TypeError, "the argument must be a PyObject of #{pytype}"
+    end
+  end
+end

data/lib/pycall/python/investigator.py

@@ -0,0 +1,6 @@
+from distutils.sysconfig import get_config_var
+import sys
+for var in ('executable', 'exec_prefix', 'prefix'):
+  print(var + ': ' + getattr(sys, var))
+for var in ('VERSION', 'LIBRARY', 'LDLIBRARY', 'LIBDIR', 'PYTHONFRAMEWORKPREFIX'):
+  print(var + ': ' + get_config_var(var))

data/lib/pycall/set.rb

@@ -0,0 +1,17 @@
+module PyCall
+  class Set
+    include PyObjectWrapper
+
+    def initialize(pyobj)
+      super(pyobj, LibPython.PySet_Type)
+    end
+
+    def length
+      LibPython.PySet_Size(__pyobj__)
+    end
+
+    def include?(obj)
+      1 == LibPython.PySet_Contains(__pyobj__, Conversions.from_ruby(obj))
+    end
+  end
+end

data/lib/pycall/slice.rb

@@ -0,0 +1,27 @@
+module PyCall
+  class Slice
+    include PyObjectWrapper
+
+    def self.new(*args)
+      start, stop, step = nil
+      case args.length
+      when 1
+        stop = args[0]
+        return super(stop) if stop.kind_of?(PyObject)
+      when 2
+        start, stop = args
+      when 3
+        start, stop, step = args
+      else
+        much_or_few = args.length > 3 ? 'much' : 'few'
+        raise ArgumentError, "too #{much_or_few} arguments (#{args.length} for 1..3)"
+      end
+      start = start ? Conversions.from_ruby(start) : PyObject.null
+      stop = stop ? Conversions.from_ruby(stop) : PyObject.null
+      step = step ? Conversions.from_ruby(step) : PyObject.null
+      pyobj = LibPython.PySlice_New(start, stop, step)
+      return pyobj.to_ruby unless pyobj.null?
+      raise PyError.fetch
+    end
+  end
+end

data/lib/pycall/tuple.rb

@@ -0,0 +1,54 @@
+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 PyObject
+        super(init)
+      end
+    end
+
+    # Make tuple from array
+    def self.[](*ary)
+      new(ary)
+    end
+
+    def initialize(pyobj)
+      super(pyobj, LibPython.PyTuple_Type)
+    end
+
+    def length
+      LibPython.PyTuple_Size(__pyobj__)
+    end
+
+    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
+      [].tap do |ary|
+        i, n = 0, length
+        while i < n
+          ary << self[i]
+          i += 1
+        end
+      end
+    end
+
+    alias to_ary to_a
+  end
+end

data/lib/pycall/types.rb

@@ -0,0 +1,15 @@
+module PyCall
+  module Types
+    def self.pyisinstance(pyobj, pytype)
+      check_pyobject(pyobj)
+      pyobj_ptr = pyobj # TODO: fix after introducing PyObject class
+      LibPython.PyObject_IsInstance(pyobj_ptr, pytype) == 1
+    end
+
+    class << self
+      private def check_pyobject(pyobj)
+        # TODO: Check whether pyobj is PyObject
+      end
+    end
+  end
+end