pycall 0.1.0.alpha.20170711 → 1.0.0

data/lib/pycall/exception.rb

@@ -1,13 +0,0 @@
-require 'pycall'
-
-module PyCall
-  @exceptions = {
-    Exception => LibPython.PyExc_RuntimeError,
-    TypeError => LibPython.PyExc_TypeError,
-  }.freeze
-
-  def self.raise_python_exception(exception)
-    pyexc = @exceptions[exception.class] || @exceptions[Exception]
-    LibPython.PyErr_SetString(pyexc, "Ruby exception: #{exception.class}: #{exception.message}")
-  end
-end

data/lib/pycall/pyobject.rb

@@ -1,58 +0,0 @@
-module PyCall
-  class PyObject
-    include PyObjectWrapper
-
-    def self.null
-      new(LibPython::PyObjectStruct.new(FFI::Pointer::NULL))
-    end
-  end
-
-  def self.getattr(pyobj, name, default=nil)
-    name = check_attr_name(name)
-    pyobj = pyobj.__pyobj__ unless pyobj.kind_of? LibPython::PyObjectStruct
-    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)
-    value = value.__pyobj__ unless pyobj.kind_of? LibPython::PyObjectStruct
-    pyobj = pyobj.__pyobj__ unless pyobj.kind_of? LibPython::PyObjectStruct
-    return self unless LibPython.PyObject_SetAttrString(pyobj, name, value) == -1
-    raise PyError.fetch
-  end
-
-  def self.hasattr?(pyobj, name)
-    name = check_attr_name(name)
-    pyobj = pyobj.__pyobj__ unless pyobj.kind_of? LibPython::PyObjectStruct
-    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)
-    pyobj = pyobj.__pyobj__ unless pyobj.kind_of? LibPython::PyObjectStruct
-    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)
-    pyobj = pyobj.__pyobj__ unless pyobj.kind_of? LibPython::PyObjectStruct
-    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/ruby_wrapper.rb

@@ -1,137 +0,0 @@
-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/type_object.rb

@@ -1,11 +0,0 @@
-module PyCall
-  class TypeObject
-    include PyObjectWrapper
-
-    def to_s
-      return "pytype(#{self.__name__})"
-    end
-
-    alias inspect to_s
-  end
-end

data/lib/pycall/types.rb

@@ -1,19 +0,0 @@
-module PyCall
-  module Types
-    def self.pyisinstance(pyobj, pytype)
-      pyobj = LibPython::PyObjectStruct.new(pyobj) if pyobj.kind_of? FFI::Pointer
-      pyobj = pyobj.__pyobj__ unless pyobj.kind_of? LibPython::PyObjectStruct
-
-      pytype = LibPython::PyObjectStruct.new(pytype) if pytype.kind_of? FFI::Pointer
-      pytype = ptype.__pyobj__ unless pytype.kind_of? LibPython::PyObjectStruct
-
-      LibPython.PyObject_IsInstance(pyobj, pytype) == 1
-    end
-
-    class << self
-      private def check_pyobject(pyobj)
-        # TODO: Check whether pyobj is PyObject
-      end
-    end
-  end
-end

data/lib/pycall/utils.rb

@@ -1,106 +0,0 @@
-module PyCall
-  module Utils
-    def append_sys_path(path_str)
-      pyobj = LibPython.PyUnicode_DecodeUTF8(path_str, path_str.bytesize, nil)
-      sys.path << pyobj
-    end
-
-    def callable?(pyobj)
-      unless pyobj.kind_of? LibPython::PyObjectStruct
-        raise TypeError, "the argument must be a Python object" unless pyobj.respond_to? :__pyobj__
-        pyobj = pyobj.__pyobj__
-      end
-      1 == LibPython.PyCallable_Check(pyobj)
-    end
-
-    def dir(pyobj)
-      pyobj = pyobj.__pyobj__ unless pyobj.kind_of? LibPython::PyObjectStruct
-      value = LibPython.PyObject_Dir(pyobj)
-      return value.to_ruby unless value.null?
-      raise PyError.fetch
-    end
-
-    def incref(pyobj)
-      LibPython.Py_IncRef(pyobj)
-      pyobj
-    end
-
-    def decref(pyobj)
-      LibPython.Py_DecRef(pyobj)
-      pyobj.send :pointer=, FFI::Pointer::NULL
-      pyobj
-    end
-
-    def int(pyobj)
-      @int ||= PyCall.eval('int')
-      @int.(pyobj)
-    end
-
-    def len(pyobj)
-      @len ||= PyCall.eval('len')
-      @len.(pyobj)
-    end
-
-    def None
-      LibPython.Py_None
-    end
-
-    def none?(pyobj)
-      case pyobj
-      when FFI::Pointer
-        ptr = pyobj
-      when LibPython::PyObjectStruct
-        ptr = pyobj.to_ptr
-      else
-        pyobj = pyobj.__pyobj__.to_ptr
-      end
-      ptr == self.None.to_ptr
-    end
-
-    def slice(*args)
-      Slice.new(*args)
-    end
-
-    def str(pyobj)
-      @str ||= PyCall.eval('str')
-      @str.(pyobj)
-    end
-
-    def sys
-      @sys ||= PyCall.import_module('sys')
-    end
-
-    def tuple(*args)
-      PyCall::Tuple[*args]
-    end
-
-    def type(pyobj)
-      @type ||= PyCall.eval('type')
-      @type.(pyobj)
-    end
-
-    def with(ctx)
-      __exit__ = PyCall.getattr(ctx, :__exit__)
-      begin
-        yield PyCall.getattr(ctx,:__enter__).()
-      rescue Exception => err
-        if err.kind_of? PyError
-          exit_value = __exit__.(err.type, err.value, err.traceback)
-        else
-          # TODO: support telling what exception has been catched
-          exit_value = __exit__.(PyCall.None, PyCall.None, PyCall.None)
-        end
-        raise err unless exit_value.equal? true
-      else
-       __exit__.(PyCall.None, PyCall.None, PyCall.None)
-      end
-    end
-
-    def format_traceback(pyobj)
-      @format_tb ||= import_module('traceback').format_tb
-      @format_tb.(pyobj)
-    end
-  end
-
-  extend Utils
-end