pycall 1.0.1-x64-mingw32

data/lib/pycall.rb

@@ -0,0 +1,91 @@
+module PyCall
+  require 'pycall/version'
+  require 'pycall/libpython'
+  require 'pycall/pyerror'
+  require 'pycall/pyobject_wrapper'
+  require 'pycall/pytypeobject_wrapper'
+  require 'pycall/init'
+
+  module_function
+
+  def builtins
+    @builtins ||= wrap_module(LibPython::API.builtins_module_ptr)
+  end
+
+  def callable?(obj)
+    case obj
+    when PyObjectWrapper
+      builtins.callable(obj.__pyptr__)
+    when PyPtr
+      builtins.callable(obj)
+    else
+      raise TypeError, "unexpected argument type #{obj.class} (expected PyCall::PyPtr or its wrapper)"
+    end
+  end
+
+  def dir(obj)
+    case obj
+    when PyObjectWrapper
+      builtins.dir(obj.__pyptr__)
+    when PyPtr
+      builtins.dir(obj)
+    else
+      raise TypeError, "unexpected argument type #{obj.class} (expected PyCall::PyPtr or its wrapper)"
+    end
+  end
+
+  def eval(expr, globals: nil, locals: nil)
+    globals ||= import_module(:__main__).__dict__
+    builtins.eval(expr, globals, locals)
+  end
+
+  def exec(code, globals: nil, locals: nil)
+    globals ||= import_module(:__main__).__dict__
+    if PYTHON_VERSION >= '3'
+      builtins.exec(code, globals, locals)
+    else
+      import_module('PyCall.six').exec_(code, globals, locals)
+    end
+  end
+
+  def import_module(name)
+    LibPython::Helpers.import_module(name)
+  end
+
+  def len(obj)
+    case obj
+    when PyObjectWrapper
+      builtins.len(obj.__pyptr__)
+    when PyPtr
+      builtins.len(obj)
+    else
+      raise TypeError, "unexpected argument type #{obj.class} (expected PyCall::PyPtr or its wrapper)"
+    end
+  end
+
+  def sys
+    @sys ||= import_module('sys')
+  end
+
+  def tuple(iterable=nil)
+    pyptr = if iterable
+              builtins.tuple.(iterable)
+            else
+              builtins.tuple.()
+            end
+    Tuple.wrap_pyptr(pyptr)
+  end
+
+  def with(ctx)
+    begin
+      yield ctx.__enter__
+    rescue PyError => err
+      raise err unless ctx.__exit__(err.type, err.value, err.traceback)
+    rescue Exception => err
+      # TODO: support telling what exception has been catched
+      raise err unless ctx.__exit__(err.class, err, err.backtrace_locations)
+    else
+      ctx.__exit__(nil, nil, nil)
+    end
+  end
+end

data/lib/pycall/conversion.rb

@@ -0,0 +1,173 @@
+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? || PyCall.none?(pyptr)
+
+      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/dict.rb

@@ -0,0 +1,48 @@
+module PyCall
+  Dict = builtins.dict
+  class Dict
+    register_python_type_mapping
+
+    include Enumerable
+
+    def self.new(h)
+      super(h, {})
+    end
+
+    def length
+      PyCall.len(self)
+    end
+
+    def has_key?(key)
+      LibPython::Helpers.dict_contains(__pyptr__, key)
+    end
+
+    alias include? has_key?
+    alias key? has_key?
+    alias member? has_key?
+
+    def [](key)
+      super
+    rescue PyError
+      nil
+    end
+
+    def delete(key)
+      v = self[key]
+      LibPython::Helpers.delitem(__pyptr__, key)
+      v
+    end
+
+    def each
+      return enum_for unless block_given?
+      LibPython::Helpers.dict_each(__pyptr__, &proc)
+      self
+    end
+
+    def to_h
+      inject({}) do |h, (k, v)|
+        h.update(k => v)
+      end
+    end
+  end
+end

data/lib/pycall/error.rb

@@ -0,0 +1,10 @@
+module PyCall
+  class Error < StandardError
+  end
+
+  class PythonNotFound < Error
+  end
+
+  class LibPythonFunctionNotFound < Error
+  end
+end

data/lib/pycall/gc_guard.rb

@@ -0,0 +1,84 @@
+require 'pycall'
+
+module PyCall
+  module GCGuard
+    @gc_guard = {}
+
+    class Key < Struct.new(:pyptr)
+      def initialize(pyptr)
+        self.pyptr = check_pyptr(pyptr)
+        # LibPython.Py_IncRef(pyptr)
+      end
+
+      def release
+        # LibPython.Py_DecRef(pyptr)
+        self.pyptr = nil
+      end
+
+      def ==(other)
+        case other
+        when Key
+          pyptr.pointer == other.pyptr.pointer
+        else
+          super
+        end
+      end
+
+      alias :eql? :==
+
+      def hash
+        pyptr.pointer.address
+      end
+
+      private
+
+      def check_pyptr(pyptr)
+        pyptr = pyptr.__pyobj__ if pyptr.respond_to? :__pyobj__
+        return pyptr if pyptr.kind_of? LibPython::PyObjectStruct
+        raise TypeError, "The argument must be a Python object"
+      end
+    end
+
+    def self.register(pyobj, obj)
+      key = Key.new(pyobj)
+      @gc_guard[key] ||= []
+      @gc_guard[key] << obj
+    end
+
+    def self.unregister(pyobj)
+      key = Key.new(pyobj)
+      @gc_guard.delete(key).tap { key.release }
+    end
+
+    def self.guarded_object_count
+      @gc_guard.length
+    end
+
+    def self.embed(pyobj, obj)
+      pyptr = pyobj.respond_to?(:__pyobj__) ? pyobj.__pyobj__ : pyobj
+      raise TypeError, "The argument must be a Python object" unless pyptr.kind_of? LibPython::PyObjectStruct
+      wo = LibPython.PyWeakref_NewRef(pyptr, weakref_callback)
+      register(wo, obj)
+      pyobj
+    end
+
+    private_class_method def self.weakref_callback
+      unless @weakref_callback
+        @weakref_callback_func = FFI::Function.new(
+          LibPython::PyObjectStruct.ptr,
+          [LibPython::PyObjectStruct.ptr, LibPython::PyObjectStruct.ptr]
+        ) do |callback, pyptr|
+          GCGuard.unregister(pyptr)
+          # LibPython.Py_DecRef(pyptr)
+          # LibPython.Py_IncRef(PyCall.None)
+          next PyCall.None
+        end
+        method_def = LibPython::PyMethodDef.new("weakref_callback", @weakref_callback_func, LibPython::METH_O, nil)
+        @weakref_callback = LibPython.PyCFunction_NewEx(method_def, nil, nil).tap {|po| LibPython.Py_IncRef(po) }
+      end
+      @weakref_callback
+    end
+  end
+
+  private_constant :GCGuard
+end

data/lib/pycall/import.rb

@@ -0,0 +1,120 @@
+require 'pycall'
+
+module PyCall
+  module Import
+    class << self
+      attr_reader :main_object
+    end
+  end
+end
+
+PyCall::Import.instance_variable_set(:@main_object, self)
+
+module PyCall
+  module Import
+    def pyimport(mod_name, as: nil)
+      as = mod_name unless as
+      check_valid_module_variable_name(mod_name, as)
+      mod = PyCall.import_module(mod_name)
+      define_singleton_method(as) { mod }
+    end
+
+    # This function is implemented as a mimic of `import_from` function defined in `Python/ceval.c`.
+    def pyfrom(mod_name, import: nil)
+      raise ArgumentError, "missing identifier(s) to be imported" unless import
+
+      mod_name = mod_name.to_str if mod_name.respond_to? :to_str
+      mod_name = mod_name.to_s if mod_name.is_a? Symbol
+
+      import = Array(import)
+      fromlist = import.map.with_index do |import_name, i|
+        case import_name
+        when assoc_array_matcher
+          import_name[0]
+        when Symbol, String
+          import_name
+        else
+          raise ArgumentError, "wrong type of import name #{import_name.class} (expected String or Symbol)"
+        end
+      end
+      from_list = PyCall.tuple(from_list)
+
+      main_dict_ptr = PyCall.import_module('__main__').__dict__.__pyptr__
+      globals = main_dict_ptr # FIXME: this should mimic to `import_name` function defined in `Python/ceval.c`.
+      locals = main_dict_ptr # FIXME: this should mimic to `import_name` function defined in `Python/ceval.c`.
+      level = 0 # TODO: support prefixed dots (#25)
+      mod = LibPython::Helpers.import_module(mod_name, globals, locals, fromlist, level)
+
+      import.each do |import_name|
+        case import_name
+        when assoc_array_matcher
+          name, asname = *import_name
+        when Symbol, String
+          name, asname = import_name, import_name
+        end
+
+        if PyCall::LibPython::Helpers.hasattr?(mod.__pyptr__, name)
+          pyobj = PyCall::LibPython::Helpers.getattr(mod.__pyptr__, name)
+          define_name(asname, pyobj)
+          next
+        end
+
+        if mod.respond_to? :__name__
+          pkgname = mod.__name__
+          fullname = "#{pkgname}.#{name}"
+          sys_modules = PyCall.import_module('sys').modules
+          if sys_modules.has_key?(fullname)
+            pyobj = module_dict[fullname]
+            define_name(asname, pyobj)
+            next
+          end
+        end
+
+        raise ArgumentError, "cannot import name #{fullname}" unless pyobj
+      end
+    end
+
+    private
+
+    def define_name(name, pyobj)
+      if callable?(pyobj) && !type_object?(pyobj)
+        define_singleton_method(name) do |*args|
+          LibPython::Helpers.call_object(pyobj.__pyptr__, *args)
+        end
+      else
+        if constant_name?(name)
+          context = self
+          context = (self == PyCall::Import.main_object) ? Object : self
+          context.module_eval { const_set(name, pyobj) }
+        else
+          define_singleton_method(name) { pyobj }
+        end
+      end
+    end
+
+    def constant_name?(name)
+      name =~ /\A[A-Z]/
+    end
+
+    def check_valid_module_variable_name(mod_name, var_name)
+      var_name = var_name.to_s if var_name.kind_of? Symbol
+      if var_name.include?('.')
+        raise ArgumentError, "#{var_name} is not a valid module variable name, use pyimport #{mod_name}, as: <name>"
+      end
+    end
+
+    def assoc_array_matcher
+      @assoc_array_matcher ||= ->(ary) do
+        ary.is_a?(Array) && ary.length == 2
+      end
+    end
+
+    def callable?(pyobj)
+      LibPython::Helpers.callable?(pyobj.__pyptr__)
+    end
+
+    def type_object?(pyobj)
+      pyobj.__pyptr__.kind_of? PyTypePtr
+    end
+  end
+end