pycall 1.2.1 → 1.4.1

data/ext/pycall/pycall_internal.h

@@ -11,10 +11,19 @@ extern "C" {
 #include <ruby.h>
 #include <ruby/encoding.h>
 #include <ruby/thread.h>
+
 #include <assert.h>
 #include <inttypes.h>
 #include <limits.h>
 
+#if defined(_WIN32)
+# define PYCALL_THREAD_WIN32
+# include <ruby/win32.h>
+#elif defined(HAVE_PTHREAD_H)
+# define PYCALL_THREAD_PTHREAD
+# include <pthread.h>
+#endif
+
 #if SIZEOF_LONG == SIZEOF_VOIDP
 # define PTR2NUM(x)   (LONG2NUM((long)(x)))
 # define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
@@ -492,6 +501,23 @@ extern PyTypeObject PyRuby_Type;
 
 PyObject * PyRuby_New(VALUE ruby_object);
 
+/* ==== thread support ==== */
+
+#if   defined(PYCALL_THREAD_WIN32)
+typedef DWORD pycall_tls_key;
+#elif defined(PYCALL_THREAD_PTHREAD)
+typedef pthread_key_t pycall_tls_key;
+#else
+# error "unsupported thread type"
+#endif
+
+int pycall_tls_create(pycall_tls_key* tls_key);
+void *pycall_tls_get(pycall_tls_key tls_key);
+int pycall_tls_set(pycall_tls_key tls_key, void *ptr);
+
+int pycall_without_gvl_p(void);
+VALUE pycall_without_gvl(VALUE (* func)(VALUE), VALUE arg);
+
 /* ==== pycall ==== */
 
 typedef struct {
@@ -637,7 +663,7 @@ Py_ssize_t pycall_python_hexversion(void);
 
 void pycall_Py_DecRef(PyObject *);
 
-RUBY_EXTERN const rb_data_type_t pycall_pyptr_data_type;
+extern const rb_data_type_t pycall_pyptr_data_type;
 size_t pycall_pyptr_memsize(void const *);
 void pycall_pyptr_free(void *);
 

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

@@ -5,6 +5,7 @@ module PyCall
   require 'pycall/pyobject_wrapper'
   require 'pycall/pytypeobject_wrapper'
   require 'pycall/pymodule_wrapper'
+  require 'pycall/iterable_wrapper'
   require 'pycall/init'
 
   module_function
@@ -58,10 +59,25 @@ 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
 
+  def iterable(obj)
+    IterableWrapper.new(obj)
+  end
+
   def len(obj)
     case obj
     when PyObjectWrapper

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/iterable_wrapper.rb

@@ -0,0 +1,32 @@
+module PyCall
+  class IterableWrapper
+    include Enumerable
+
+    def initialize(obj)
+      @obj = check_iterable(obj)
+    end
+
+    private def check_iterable(obj)
+      unless PyCall.hasattr?(obj, :__iter__)
+        raise ArgumentError, "%p object is not iterable" % obj
+      end
+      obj
+    end
+
+    def each
+      return enum_for(__method__) unless block_given?
+      iter = @obj.__iter__()
+      while true
+        begin
+          yield iter.__next__()
+        rescue PyCall::PyError => err
+          if err.type == PyCall.builtins.StopIteration
+            break
+          else
+            raise err
+          end
+        end
+      end
+    end
+  end
+end

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