pycall 1.2.0 → 1.4.0

data/ext/pycall/ruby_wrapper.c

@@ -356,11 +356,16 @@ PyRuby_getattro_with_gvl(PyRubyObject *pyro, PyObject *pyobj_name)
 
 VALUE cPyRubyPtr;
 
-const rb_data_type_t pycall_pyrubyptr_data_type = {
+static rb_data_type_t pycall_pyrubyptr_data_type = {
   "PyCall::PyRubyPtr",
   { 0, pycall_pyptr_free, pycall_pyptr_memsize, },
 #ifdef RUBY_TYPED_FREE_IMMEDIATELY
-  &pycall_pyptr_data_type, 0, RUBY_TYPED_FREE_IMMEDIATELY
+# if defined  _WIN32 && !defined __CYGWIN__
+  0,
+# else
+  &pycall_pyptr_data_type,
+# endif
+  0, RUBY_TYPED_FREE_IMMEDIATELY
 #endif
 };
 
@@ -462,6 +467,10 @@ pycall_init_ruby_wrapper(void)
 
   /* PyCall::PyRubyPtr */
 
+#if defined _WIN32 && !defined __CYGWIN__
+  pycall_pyrubyptr_data_type.parent = &pycall_pyptr_data_type;
+#endif
+
   cPyRubyPtr = rb_define_class_under(mPyCall, "PyRubyPtr", cPyPtr);
   rb_define_alloc_func(cPyRubyPtr, pycall_pyruby_allocate);
   rb_define_method(cPyRubyPtr, "__ruby_object_id__", pycall_pyruby_get_ruby_object_id, 0);

data/ext/pycall/thread.c

@@ -0,0 +1,36 @@
+#include "pycall_internal.h"
+
+#if defined(PYCALL_THREAD_WIN32)
+int pycall_tls_create(pycall_tls_key *tls_key)
+{
+  *tls_key = TlsAlloc();
+  return *tls_key == TLS_OUT_OF_INDEXES;
+}
+
+void *pycall_tls_get(pycall_tls_key tls_key)
+{
+  return TlsGetValue(tls_key);
+}
+
+int pycall_tls_set(pycall_tls_key tls_key, void *ptr)
+{
+  return 0 == TlsSetValue(tls_key, ptr);
+}
+#endif
+
+#if defined(PYCALL_THREAD_PTHREAD)
+int pycall_tls_create(pycall_tls_key *tls_key)
+{
+  return pthread_key_create(tls_key, NULL);
+}
+
+void *pycall_tls_get(pycall_tls_key tls_key)
+{
+  return pthread_getspecific(tls_key);
+}
+
+int pycall_tls_set(pycall_tls_key tls_key, void *ptr)
+{
+  return pthread_setspecific(tls_key, ptr);
+}
+#endif

data/lib/pycall.rb

@@ -58,6 +58,17 @@ module PyCall
     LibPython::Helpers.hasattr?(obj.__pyptr__, name)
   end
 
+  def same?(left, right)
+    case left
+    when PyObjectWrapper
+      case right
+      when PyObjectWrapper
+        return left.__pyptr__ == right.__pyptr__
+      end
+    end
+    false
+  end
+
   def import_module(name)
     LibPython::Helpers.import_module(name)
   end

data/lib/pycall/dict.rb

@@ -33,9 +33,9 @@ module PyCall
       v
     end
 
-    def each
+    def each(&block)
       return enum_for unless block_given?
-      LibPython::Helpers.dict_each(__pyptr__, &proc)
+      LibPython::Helpers.dict_each(__pyptr__, &block)
       self
     end
 

data/lib/pycall/init.rb

@@ -30,20 +30,15 @@ module PyCall
       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.so'
+
+    PyCall.sys.path.append(File.expand_path('../python', __FILE__))
 
     require 'pycall/dict'
     require 'pycall/list'

data/lib/pycall/iruby_helper.rb

@@ -1,4 +1,4 @@
-require 'pycall'
+require 'pycall' unless defined?(::PyCall)
 require 'iruby'
 
 module PyCall

data/lib/pycall/libpython/finder.rb

@@ -1,5 +1,6 @@
 require 'pycall/error'
 require 'fiddle'
+require 'pathname'
 
 module PyCall
   module LibPython
@@ -27,73 +28,114 @@ module PyCall
         def find_python_config(python = nil)
           python ||= DEFAULT_PYTHON
           Array(python).each do |python_cmd|
-            python_config = investigate_python_config(python_cmd)
-            return [python_cmd, python_config] unless python_config.empty?
+            begin
+              python_config = investigate_python_config(python_cmd)
+              return [python_cmd, python_config] unless python_config.empty?
+            rescue
+            end
           end
-        rescue
-          raise ::PyCall::PythonNotFound
-        else
           raise ::PyCall::PythonNotFound
         end
 
         def find_libpython(python = nil)
           debug_report("find_libpython(#{python.inspect})")
           python, python_config = find_python_config(python)
-
-          set_PYTHONHOME(python_config)
-          libs = make_libs(python_config)
-          libpaths = make_libpaths(python_config)
-
-          # Try LIBPYTHON environment variable first.
-          if (libpython = ENV['LIBPYTHON'])
-            if File.file?(libpython)
+          suffix = python_config[:SHLIB_SUFFIX]
+
+          use_conda = (ENV.fetch("CONDA_PREFIX", nil) == File.dirname(python_config[:executable]))
+          python_home = if !ENV.key?("PYTHONHOME") || use_conda
+                          python_config[:PYTHONHOME]
+                        else
+                          ENV["PYTHONHOME"]
+                        end
+          ENV["PYTHONHOME"] = python_home
+
+          candidate_paths(python_config) do |path|
+            debug_report("Candidate: #{path}")
+            normalized = normalize_path(path, suffix)
+            if normalized
+              debug_report("Trying to dlopen: #{normalized}")
               begin
-                return dlopen(libpython)
+                return dlopen(normalized)
               rescue Fiddle::DLError
-                debug_report "#{$!.class}: #{$!.message}"
-              else
-                debug_report "Success to dlopen #{libpython.inspect} from ENV['LIBPYTHON']"
+                debug_report "dlopen(#{normalized.inspect}) => #{$!.class}: #{$!.message}"
               end
+            else
+              debug_report("Not found.")
             end
-            warn "WARNING(#{self}.#{__method__}) Ignore the wrong libpython location specified in ENV['LIBPYTHON']."
           end
+        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
+        def candidate_names(python_config)
+          names = []
+          names << python_config[:LDLIBRARY] if python_config[:LDLIBRARY]
+          suffix = python_config[:SHLIB_SUFFIX]
+          if python_config[:LIBRARY]
+            ext = File.extname(python_config[:LIBRARY])
+            names << python_config[:LIBRARY].delete_suffix(ext) + suffix
+          end
+          dlprefix = if windows? then "" else "lib" end
+          sysdata = {
+            v_major:  python_config[:version_major],
+            VERSION:  python_config[:VERSION],
+            ABIFLAGS: python_config[:ABIFLAGS],
+          }
+          [
+            "python%{VERSION}%{ABIFLAGS}" % sysdata,
+            "python%{VERSION}" % sysdata,
+            "python%{v_major}" % sysdata,
+            "python"
+          ].each do |stem|
+            names << "#{dlprefix}#{stem}#{suffix}"
           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}"
+          names.compact!
+          names.uniq!
+
+          debug_report("candidate_names: #{names}")
+          return names
+        end
+
+        def candidate_paths(python_config)
+          # The candidate library that linked by executable
+          yield python_config[:linked_libpython]
+
+          lib_dirs = make_libpaths(python_config)
+          lib_basenames = candidate_names(python_config)
+
+          # candidates by absolute paths
+          lib_dirs.each do |dir|
+            lib_basenames.each do |name|
+              yield File.join(dir, name)
             end
           end
 
-          raise ::PyCall::PythonNotFound
+          # library names for searching in system library paths
+          lib_basenames.each do |name|
+            yield name
+          end
+        end
+
+        def normalize_path(path, suffix, apple_p=apple?)
+          return nil if path.nil?
+          case
+          when path.nil?,
+               Pathname.new(path).relative?
+            nil
+          when File.exist?(path)
+            File.realpath(path)
+          when File.exist?(path + suffix)
+            File.realpath(path + suffix)
+          when apple_p
+            normalize_path(remove_suffix_apple(path), ".so", false)
+          else
+            nil
+          end
+        end
+
+        # Strip off .so or .dylib
+        def remove_suffix_apple(path)
+          path.sub(/\.(?:dylib|so)\z/, '')
         end
 
         def investigate_python_config(python)
@@ -120,47 +162,25 @@ module PyCall
           File.expand_path('../../python/investigator.py', __FILE__)
         end
 
-        def set_PYTHONHOME(python_config)
-          if !ENV.has_key?('PYTHONHOME') && python_config[:conda]
-            case RUBY_PLATFORM
-            when /mingw32/, /cygwin/, /mswin/
-              ENV['PYTHONHOME'] = python_config[:exec_prefix]
-            else
-              ENV['PYTHONHOME'] = python_config.values_at(:prefix, :exec_prefix).join(':')
-            end
-          end
-        end
+        def make_libpaths(python_config)
+          libpaths = python_config.values_at(:LIBPL, :srcdir, :LIBDIR)
 
-        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))
+          if windows?
+            libpaths << File.dirname(python_config[:executable])
+          else
+            libpaths << File.expand_path('../../lib', python_config[:executable])
           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)
+          if apple?
+            libpaths << python_config[:PYTHONFRAMEWORKPREFIX]
           end
-          libpaths << python_config[:PYTHONFRAMEWORKPREFIX]
+
           exec_prefix = python_config[:exec_prefix]
-          libpaths << exec_prefix << File.join(exec_prefix, 'lib')
+          libpaths << exec_prefix
+          libpaths << File.join(exec_prefix, 'lib')
+
           libpaths.compact!
+          libpaths.uniq!
 
           debug_report "libpaths: #{libpaths.inspect}"
           return libpaths
@@ -168,6 +188,14 @@ module PyCall
 
         private
 
+        def windows?
+          Fiddle::WINDOWS
+        end
+
+        def apple?
+          RUBY_PLATFORM.include?("darwin")
+        end
+
         def dlopen(libname)
           Fiddle.dlopen(libname).tap do |handle|
             debug_report("dlopen(#{libname.inspect}) = #{handle.inspect}") if handle
@@ -186,3 +214,22 @@ module PyCall
     end
   end
 end
+
+if __FILE__ == $0
+  require "pp"
+  python, python_config = PyCall::LibPython::Finder.find_python_config
+
+  puts "python_config:"
+  pp python_config
+
+  puts "\ncandidate_names:"
+  p PyCall::LibPython::Finder.candidate_names(python_config)
+
+  puts "\nlib_dirs:"
+  p PyCall::LibPython::Finder.make_libpaths(python_config)
+
+  puts "\ncandidate_paths:"
+  PyCall::LibPython::Finder.candidate_paths(python_config) do |path|
+    puts "- #{path}"
+  end
+end

data/lib/pycall/list.rb

@@ -13,9 +13,9 @@ module PyCall
       PyCall.len(self)
     end
 
-    def each
+    def each(&block)
       return enum_for unless block_given?
-      LibPython::Helpers.sequence_each(__pyptr__, &proc)
+      LibPython::Helpers.sequence_each(__pyptr__, &block)
       self
     end
 

data/lib/pycall/pyobject_wrapper.rb

@@ -178,7 +178,7 @@ module PyCall
   def check_isclass(pyptr)
     pyptr = pyptr.__pyptr__ if pyptr.kind_of? PyObjectWrapper
     return if pyptr.kind_of? LibPython::API::PyType_Type
-    return defined?(LibPython::API::PyClass_Type) && pyptr.kind_of?(LibPython::API::PyClass_Type)
+    return if defined?(LibPython::API::PyClass_Type) && pyptr.kind_of?(LibPython::API::PyClass_Type)
     raise TypeError, "PyType object is required"
   end
 end

data/lib/pycall/python/investigator.py

@@ -1,12 +1,85 @@
-from distutils.sysconfig import get_config_var
+#!/usr/bin/env python
+
+import ctypes.util
+from distutils.sysconfig import get_config_var, get_python_version
+import os
 import sys
 
-def conda():
-    return 'conda' in sys.version or 'Continuum' in sys.version
+is_windows = os.name == "nt"
+
+def linked_libpython():
+    if is_windows:
+        return _linked_libpython_windows()
+    return _linked_libpython_unix()
+
+class Dl_info(ctypes.Structure):
+    _fields_ = [
+        ("dli_fname", ctypes.c_char_p),
+        ("dli_fbase", ctypes.c_void_p),
+        ("dli_sname", ctypes.c_char_p),
+        ("dli_saddr", ctypes.c_void_p),
+    ]
+
+def _linked_libpython_unix():
+    libdl = ctypes.CDLL(ctypes.util.find_library("dl"))
+    libdl.dladdr.argtypes = [ctypes.c_void_p, ctypes.POINTER(Dl_info)]
+    libdl.dladdr.restype = ctypes.c_int
+
+    dlinfo = Dl_info()
+    retcode = libdl.dladdr(
+            ctypes.cast(ctypes.pythonapi.Py_GetVersion, ctypes.c_void_p),
+            ctypes.pointer(dlinfo))
+    if retcode == 0:  # means error
+        return None
+    path = os.path.realpath(dlinfo.dli_fname.decode())
+    if path == os.path.realpath(sys.executable):
+        return None
+    return path
+
+def _linked_libpython_windows():
+    # Based on: https://stackoverflow.com/a/16659821
+    from ctypes.wintypes import HANDLE, LPWSTR, DWORD
+
+    GetModuleFileName = ctypes.windll.kernel32.GetModuleFileNameW
+    GetModuleFileName.argtypes = [HANDLE, LPWSTR, DWORD]
+    GetModuleFileName.restype = DWORD
+
+    MAX_PATH = 260
+    try:
+        buf = ctypes.create_unicode_buffer(MAX_PATH)
+        GetModuleFileName(ctypes.pythonapi._handle, buf, MAX_PATH)
+        return buf.value
+    except (ValueError, OSError):
+        return None
+
+print("linked_libpython: {val}".format(val=(linked_libpython() or "None")))
+
+sys_keys = [ "executable", "exec_prefix", "prefix" ]
+
+for var in sys_keys:
+    print("{var}: {val}".format(var=var, val=(getattr(sys, var) or "None")))
+
+config_keys = [ "INSTSONAME", "LIBDIR", "LIBPL", "LIBRARY", "LDLIBRARY",
+                "MULTIARCH", "PYTHONFRAMEWORKPREFIX", "SHLIB_SUFFIX", "srcdir" ]
+
+for var in config_keys:
+    print("{var}: {val}".format(var=var, val=(get_config_var(var) or "None")))
+
+print("ABIFLAGS: {val}".format(val=get_config_var("ABIFLAGS") or get_config_var("abiflags") or "None"))
+
+version = get_python_version() or \
+          "{v.major}.{v.minor}".format(v=sys.version_info) or \
+          get_config_var("VERSION")
+print("VERSION: {val}".format(val=version))
 
-for var in ('executable', 'exec_prefix', 'prefix'):
-  print(var + ': ' + str(getattr(sys, var)))
-print('conda: ' + ('true' if conda() else 'false'))
-print('multiarch: ' + str(getattr(getattr(sys, 'implementation', sys), '_multiarch', None)))
-for var in ('VERSION', 'INSTSONAME', 'LIBRARY', 'LDLIBRARY', 'LIBDIR', 'PYTHONFRAMEWORKPREFIX', 'MULTIARCH'):
-  print(var + ': ' + str(get_config_var(var)))
+if is_windows:
+    if hasattr(sys, "base_exec_prefix"):
+        PYTHONHOME = sys.base_exec_prefix
+    else:
+        PYTHONHOME = sys.exec_prefix
+else:
+    if hasattr(sys, "base_exec_prefix"):
+        PYTHONHOME = ":".join([sys.base_prefix, sys.base_exec_prefix])
+    else:
+        PYTHONHOME = ":".join([sys.prefix, sys.exec_prefix])
+print("PYTHONHOME: {val}".format(val=PYTHONHOME))