pycall 1.0.1-x86-mingw32

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

data/lib/pycall/init.rb

@@ -0,0 +1,55 @@
+module PyCall
+  def self.const_missing(name)
+    case name
+    when :PyPtr, :PyTypePtr, :PyObjectWrapper, :PYTHON_DESCRIPTION, :PYTHON_VERSION
+      PyCall.init
+      const_get(name)
+    else
+      super
+    end
+  end
+
+  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
+
+  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
+
+    ENV['PYTHONPATH'] = [ File.expand_path('../python', __FILE__), ENV['PYTHONPATH'] ].compact.join(File::PATH_SEPARATOR)
+
+    LibPython.instance_variable_set(:@handle, LibPython::Finder.find_libpython(python))
+    class << LibPython
+      undef_method :handle
+      attr_reader :handle
+    end
+
+    begin
+      major, minor, _ = RUBY_VERSION.split('.')
+      require "#{major}.#{minor}/pycall.so"
+    rescue LoadError
+      require 'pycall.so'
+    end
+
+    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
+end

data/lib/pycall/iruby_helper.rb

@@ -0,0 +1,40 @@
+require 'pycall'
+require 'iruby'
+
+module PyCall
+  module IRubyHelper
+    private
+
+    def check_pyobject_respond_to_format_method(obj, method_name)
+      return false unless obj.kind_of? PyObject
+      return false unless PyCall.hasattr?(obj, method_name)
+      PyCall.getattr(obj, method_name).kind_of? PyCall::LibPython.PyMethod_Type
+    end
+
+    def register_pyobject_formatter(format_name, mime, priority_value=0)
+      method_name = :"_repr_#{format_name}_"
+      match do |obj|
+        check_pyobject_respond_to_format_method(obj, method_name)
+      end
+      priority priority_value
+      format mime do |obj|
+        PyCall.getattr(obj, method_name).()
+      end
+    end
+  end
+end
+
+::IRuby::Display::Registry.module_eval do
+  extend PyCall::IRubyHelper
+
+  register_pyobject_formatter :html, 'text/html'
+  register_pyobject_formatter :markdown, 'text/markdown'
+  register_pyobject_formatter :svg, 'image/svg+xml'
+  register_pyobject_formatter :png, 'image/png'
+  register_pyobject_formatter :jpeg, 'image/jpeg'
+  register_pyobject_formatter :latex, 'text/latex'
+  register_pyobject_formatter :json, 'application/json'
+  register_pyobject_formatter :javascript, 'application/javascript'
+  register_pyobject_formatter :pdf, 'application/pdf'
+  register_pyobject_formatter :pretty, 'text/plain', -1000
+end

data/lib/pycall/libpython/finder.rb

@@ -0,0 +1,170 @@
+require 'pycall/error'
+require 'fiddle'
+
+module PyCall
+  module LibPython
+    module Finder
+      case RUBY_PLATFORM
+      when /cygwin/
+        libprefix = 'cyg'
+        libsuffix = 'dll'
+      when /mingw/, /mswin/
+        libprefix = ''
+        libsuffix = 'dll'
+      when /darwin/
+        libsuffix = 'dylib'
+      end
+
+      LIBPREFIX = libprefix || 'lib'
+      LIBSUFFIX = libsuffix || 'so'
+
+      class << self
+        def find_libpython(python = nil)
+          debug_report("find_libpython(#{python.inspect})")
+	  if python
+	    begin
+	      python_config = investigate_python_config(python)
+	    rescue
+              raise ::PyCall::PythonNotFound
+	    end
+          else
+            %w[python python3].each do |python_cmd|
+	      begin
+		python_config = investigate_python_config(python_cmd)
+		python = python_cmd
+                break
+	      rescue
+		raise ::PyCall::PythonNotFound
+	      end
+	    end
+	  end
+
+          libs = make_libs(python_config)
+          libpaths = make_libpaths(python_config)
+
+          # Try LIBPYTHON environment variable first.
+          if (libpython = ENV['LIBPYTHON'])
+            if File.file?(libpython)
+              begin
+                return dlopen(libpython)
+              rescue Fiddle::DLError
+                debug_report "#{$!.class}: #{$!.message}"
+              else
+                debug_report "Success to dlopen #{libpython.inspect} from ENV['LIBPYTHON']"
+              end
+            end
+            warn "WARNING(#{self}.#{__method__}) Ignore the wrong libpython location specified in ENV['LIBPYTHON']."
+          end
+
+          # Find libpython (we hope):
+          multiarch = python_config[:MULTIARCH] || python_config[:multiarch]
+          libs.each do |lib|
+            libpaths.each do |libpath|
+              libpath_libs = [ File.join(libpath, lib) ]
+              libpath_libs << File.join(libpath, multiarch, lib) if multiarch
+              libpath_libs.each do |libpath_lib|
+                [ libpath_lib, "#{libpath_lib}.#{LIBSUFFIX}" ].each do |fullname|
+                  unless File.file? fullname
+                    debug_report "Unable to find #{fullname}"
+                    next
+                  end
+                  begin
+                    return dlopen(libpath_lib)
+                  rescue Fiddle::DLError
+                    debug_report "#{$!.class}: #{$!.message}"
+                  else
+                    debug_report "Success to dlopen #{libpaht_lib}"
+                  end
+                end
+              end
+            end
+          end
+
+          # Find libpython in the system path
+          libs.each do |lib|
+            begin
+              return dlopen(lib)
+            rescue Fiddle::DLError
+              debug_report "#{$!.class}: #{$!.message}"
+            else
+              debug_report "Success to dlopen #{lib}"
+            end
+          end
+
+          raise ::PyCall::PythonNotFound
+        end
+
+        def investigate_python_config(python)
+          python_env = { 'PYTHONIOENCODING' => 'UTF-8' }
+          debug_report("investigate_python_config(#{python.inspect})")
+          IO.popen(python_env, [python, python_investigator_py], 'r') do |io|
+            {}.tap do |config|
+              io.each_line do |line|
+                key, value = line.chomp.split(': ', 2)
+                config[key.to_sym] = value if value != 'None'
+              end
+            end
+          end
+        rescue Errno::ENOENT
+          raise PyCall::PythonInvestigationFailed
+        end
+
+        def python_investigator_py
+          File.expand_path('../../python/investigator.py', __FILE__)
+        end
+
+        def make_libs(python_config)
+          libs = []
+          %i(INSTSONAME LDLIBRARY).each do |key|
+            lib = python_config[key]
+            libs << lib << File.basename(lib) if lib
+          end
+          if (lib = python_config[:LIBRARY])
+            libs << File.basename(lib, File.extname(lib))
+          end
+
+          v = python_config[:VERSION]
+          libs << "#{LIBPREFIX}python#{v}" << "#{LIBPREFIX}python"
+          libs.uniq!
+
+          debug_report "libs: #{libs.inspect}"
+          return libs
+        end
+
+        def make_libpaths(python_config)
+          executable = python_config[:executable]
+          libpaths = [ python_config[:LIBDIR] ]
+          if Fiddle::WINDOWS
+            libpaths << File.dirname(executable)
+          else
+            libpaths << File.expand_path('../../lib', executable)
+          end
+          libpaths << python_config[:PYTHONFRAMEWORKPREFIX]
+          exec_prefix = python_config[:exec_prefix]
+          libpaths << exec_prefix << File.join(exec_prefix, 'lib')
+          libpaths.compact!
+
+          debug_report "libpaths: #{libpaths.inspect}"
+          return libpaths
+        end
+
+        private
+
+        def dlopen(libname)
+          Fiddle.dlopen(libname).tap do |handle|
+            debug_report("dlopen(#{libname.inspect}) = #{handle.inspect}") if handle
+          end
+        end
+
+        def debug_report(message)
+          return unless debug?
+          $stderr.puts "DEBUG(find_libpython) #{message}"
+        end
+
+        def debug?
+          @debug ||= (ENV['PYCALL_DEBUG_FIND_LIBPYTHON'] == '1')
+        end
+      end
+    end
+  end
+end

data/lib/pycall/libpython/pyobject_struct.rb

@@ -0,0 +1,30 @@
+require 'ffi'
+
+module PyCall
+  module LibPython
+    class PyObjectStruct < FFI::Struct
+    end
+
+    class PyTypeObjectStruct < PyObjectStruct
+    end
+
+    class PyObjectStruct < FFI::Struct
+      layout ob_refcnt: :ssize_t,
+             ob_type:   PyTypeObjectStruct.by_ref
+
+      def self.null
+        new(FFI::Pointer::NULL)
+      end
+
+      def py_none?
+        PyCall.none?(self)
+      end
+
+      def kind_of?(klass)
+        klass = klass.__pyobj__ if klass.kind_of? PyObjectWrapper
+        return super unless klass.kind_of? PyObjectStruct
+        PyCall::Types.pyisinstance(self, klass)
+      end
+    end
+  end
+end