pycall 0.1.0.alpha.20170711 → 1.0.0

data/lib/pycall.rb

@@ -1,19 +1,91 @@
-require "pycall/version"
-require "pycall/libpython"
-require "pycall/gc_guard"
-require "pycall/exception"
-require "pycall/pyobject_wrapper"
-require "pycall/pyobject"
-require "pycall/pyerror"
-require "pycall/eval"
-require "pycall/types"
-require "pycall/conversion"
-require "pycall/type_object"
-require "pycall/tuple"
-require "pycall/list"
-require "pycall/dict"
-require "pycall/set"
-require "pycall/slice"
-require "pycall/utils"
-require "pycall/ruby_wrapper"
-require "pycall/init"
+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/dict.rb

@@ -1,102 +1,48 @@
 module PyCall
+  Dict = builtins.dict
   class Dict
-    include PyObjectWrapper
+    register_python_type_mapping
 
-    def self.new(init=nil)
-      case init
-      when LibPython::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 PyObject or a Hash"
-      end
-    end
-
-    def [](key)
-      key = key.to_s if key.is_a? Symbol
-      key = key.__pyobj__ if key.respond_to?(:__pyobj__)
-      value = if key.is_a? String
-                LibPython.PyDict_GetItemString(__pyobj__, key).to_ruby
-              else
-                LibPython.PyDict_GetItem(__pyobj__, key).to_ruby
-              end
-    ensure
-      case value
-      when LibPython::PyObjectStruct
-        PyCall.incref(value)
-      when PyObjectWrapper
-        PyCall.incref(value.__pyobj__)
-      end
-    end
-
-    def []=(key, value)
-      key = key.to_s if key.is_a? Symbol
-      key = key.__pyobj__ if key.respond_to?(:__pyobj__)
-      value = Conversions.from_ruby(value)
-      value = value.__pyobj__ unless value.kind_of? LibPython::PyObjectStruct
-      if key.is_a? String
-        LibPython.PyDict_SetItemString(__pyobj__, key, value)
-      else
-        LibPython.PyDict_SetItem(__pyobj__, key, value)
-      end
-      value
-    end
-
-    def delete(key)
-      key = key.to_s if key.is_a? Symbol
-      key = key.__pyobj__ if key.respond_to?(:__pyobj__)
-      if key.is_a? String
-        value = LibPython.PyDict_GetItemString(__pyobj__, key).to_ruby
-        LibPython.PyDict_DelItemString(__pyobj__, key)
-      else
-        value = LibPython.PyDict_GetItem(__pyobj__, key).to_ruby
-        LibPython.PyDict_DelItem(__pyobj__, key)
-      end
-      value
-    end
-
-    def size
-      LibPython.PyDict_Size(__pyobj__)
-    end
+    include Enumerable
 
-    alias length size
-
-    def keys
-      LibPython.PyDict_Keys(__pyobj__).to_ruby
+    def self.new(h)
+      super(h, {})
     end
 
-    def values
-      LibPython.PyDict_Values(__pyobj__).to_ruby
+    def length
+      PyCall.len(self)
     end
 
     def has_key?(key)
-      key = Conversions.from_ruby(key)
-      value = LibPython.PyDict_Contains(__pyobj__, key)
-      raise PyError.fetch if value == -1
-      1 == value
+      LibPython::Helpers.dict_contains(__pyptr__, key)
     end
 
-    def default=(val)
-      # TODO: PYDict_SetDefault
+    alias include? has_key?
+    alias key? has_key?
+    alias member? has_key?
+
+    def [](key)
+      super
+    rescue PyError
+      nil
     end
 
-    def dup
-      # TODO: PyDict_Copy
+    def delete(key)
+      v = self[key]
+      LibPython::Helpers.delitem(__pyptr__, key)
+      v
     end
 
-    def to_a
-      LibPython.PyDict_Items(__pyobj__).to_ruby
+    def each
+      return enum_for unless block_given?
+      LibPython::Helpers.dict_each(__pyptr__, &proc)
+      self
     end
 
-    def to_hash
-      # TODO: PyDict_Next
+    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/import.rb

@@ -2,57 +2,48 @@ require 'pycall'
 
 module PyCall
   module Import
-    def self.main_object
-      @main_object
+    class << self
+      attr_reader :main_object
     end
   end
 end
 
-main_object = self
-PyCall::Import.class_eval { @main_object = main_object }
+PyCall::Import.instance_variable_set(:@main_object, self)
 
 module PyCall
   module Import
     def pyimport(mod_name, as: nil)
-      case as
-      when nil
-        as = mod_name
-      end
-
+      as = mod_name unless as
       check_valid_module_variable_name(mod_name, as)
-
       mod = PyCall.import_module(mod_name)
-      raise PyError.fetch unless mod
-
       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 identifiers to be imported" unless import
+      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 = LibPython.PyTuple_New(import.length)
-      import.each_with_index do |import_name, i|
-        name = case import_name
-               when assoc_array_matcher
-                 import_name[0]
-               when Symbol, String
-                 import_name
-               end
-        LibPython.PyTuple_SetItem(fromlist, i, Conversions.from_ruby(name))
+      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 = PyCall::Eval.__send__ :main_dict
-      globals = main_dict.__pyobj__ # FIXME: this should mimic to `import_name` function defined in `Python/ceval.c`.
-      locals = main_dict.__pyobj__ # FIXME: this should mimic to `import_name` function defined in `Python/ceval.c`.
+      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.PyImport_ImportModuleLevel(mod_name, globals, locals, fromlist, level)
-      raise PyError.fetch if mod.null?
-      mod = mod.to_ruby
+      mod = LibPython::Helpers.import_module(mod_name, globals, locals, fromlist, level)
 
       import.each do |import_name|
         case import_name
@@ -62,18 +53,18 @@ module PyCall
           name, asname = import_name, import_name
         end
 
-        if PyCall.hasattr?(mod, name)
-          pyobj = PyCall.getattr(mod, name)
+        if PyCall::LibPython::Helpers.hasattr?(mod.__pyptr__, name)
+          pyobj = PyCall::LibPython::Helpers.getattr(mod.__pyptr__, name)
           define_name(asname, pyobj)
           next
         end
 
-        if PyCall.hasattr?(mod, :__name__)
-          pkgname = PyCall.getattr(mod, :__name__)
+        if mod.respond_to? :__name__
+          pkgname = mod.__name__
           fullname = "#{pkgname}.#{name}"
-          module_dict = LibPython.PyImport_GetModuleDict()
-          if PyCall.getattr(module_dict, fullname)
-            pyobj = PyCall.getattr(module_dict, fullname)
+          sys_modules = PyCall.import_module('sys').modules
+          if sys_modules.has_key?(fullname)
+            pyobj = module_dict[fullname]
             define_name(asname, pyobj)
             next
           end
@@ -86,12 +77,18 @@ module PyCall
     private
 
     def define_name(name, pyobj)
-      if constant_name?(name)
-        context = self
-        context = (self == PyCall::Import.main_object) ? Object : self
-        context.module_eval { const_set(name, pyobj) }
+      if callable?(pyobj) && !type_object?(pyobj)
+        define_singleton_method(name) do |*args|
+          LibPython::Helpers.call_object(pyobj.__pyptr__, *args)
+        end
       else
-        define_singleton_method(name) { pyobj }
+        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
 
@@ -111,5 +108,13 @@ module PyCall
         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

data/lib/pycall/init.rb

@@ -1,31 +1,55 @@
 module PyCall
-  private_class_method def self.__initialize_pycall__
-    initialized = (0 != PyCall::LibPython.Py_IsInitialized())
-    return if initialized
+  def self.const_missing(name)
+    case name
+    when :PyPtr, :PyTypePtr, :PyObjectWrapper, :PYTHON_DESCRIPTION, :PYTHON_VERSION
+      PyCall.init
+      const_get(name)
+    else
+      super
+    end
+  end
 
-    PyCall::LibPython.Py_InitializeEx(0)
+  module LibPython
+    def self.const_missing(name)
+      case name
+      when :API, :Conversion, :Helpers, :PYTHON_DESCRIPTION, :PYTHON_VERSION
+        PyCall.init
+        const_get(name)
+      else
+        super
+      end
+    end
+  end
 
-    FFI::MemoryPointer.new(:pointer, 1) do |argv|
-      argv.write_pointer(FFI::MemoryPointer.from_string(""))
-      PyCall::LibPython.PySys_SetArgvEx(0, argv, 0)
+  def self.init(python = ENV['PYTHON'])
+    return false if LibPython.instance_variable_defined?(:@handle)
+    class << PyCall
+      remove_method :const_missing
+    end
+    class << PyCall::LibPython
+      remove_method :const_missing
     end
 
-    @builtin = LibPython.PyImport_ImportModule(PYTHON_VERSION < '3.0.0' ? '__builtin__' : 'builtins').to_ruby
+    ENV['PYTHONPATH'] = [ File.expand_path('../python', __FILE__), ENV['PYTHONPATH'] ].compact.join(File::PATH_SEPARATOR)
 
-    begin
-      import_module('stackless')
-      @has_stackless_extension = true
-    rescue PyError
-      @has_stackless_extension = false
+    LibPython.instance_variable_set(:@handle, LibPython::Finder.find_libpython(python))
+    class << LibPython
+      undef_method :handle
+      attr_reader :handle
     end
 
-    __initialize_ruby_wrapper__
-  end
+    begin
+      major, minor, _ = RUBY_VERSION.split('.')
+      require "#{major}.#{minor}/pycall.so"
+    rescue LoadError
+      require 'pycall.so'
+    end
 
-  class << self
-    attr_reader :builtin
-    attr_reader :has_stackless_extension
+    require 'pycall/dict'
+    require 'pycall/list'
+    require 'pycall/slice'
+    const_set(:PYTHON_VERSION, LibPython::PYTHON_VERSION)
+    const_set(:PYTHON_DESCRIPTION, LibPython::PYTHON_DESCRIPTION)
+    true
   end
-
-  __initialize_pycall__
 end