pycall 1.0.1-x86-mingw32

data/lib/pycall/libpython/pytypeobject_struct.rb

@@ -0,0 +1,273 @@
+require 'pycall/libpython/pyobject_struct'
+
+module PyCall
+  module LibPython
+    # types:
+    T_SHORT  = 0
+    T_INT    = 1
+    T_LONG   = 2
+    T_FLOAT  = 3
+    T_DOUBLE = 4
+    T_STRING = 5
+    T_OBJECT = 6
+    T_CHAR   = 7
+    T_BYTE   = 8
+    T_UBYTE  = 9
+    T_USHORT = 10
+    T_UINT   = 11
+    T_ULONG  = 12
+    T_STRING_INPLACE = 13
+    T_BOOL      = 14
+    T_OBJECT_EX = 16
+    T_LONGLONG  = 17 # added in Python 2.5
+    T_ULONGLONG = 18 # added in Python 2.5
+    T_PYSSIZET  = 19 # added in Python 2.6
+    T_NONE      = 20 # added in Python 3.0
+
+    # flags:
+    READONLY = 1
+    READ_RESTRICTED = 2
+    PY_WRITE_RESTRICTED = 4
+    RESTRICTED = (READ_RESTRICTED | PY_WRITE_RESTRICTED)
+
+    # Python 2.7
+    Py_TPFLAGS_HAVE_GETCHARBUFFER  = 0x00000001<<0
+    Py_TPFLAGS_HAVE_SEQUENCE_IN    = 0x00000001<<1
+    Py_TPFLAGS_GC                  = 0 # was sometimes (0x00000001<<2) in Python <= 2.1
+    Py_TPFLAGS_HAVE_INPLACEOPS     = 0x00000001<<3
+    Py_TPFLAGS_CHECKTYPES          = 0x00000001<<4
+    Py_TPFLAGS_HAVE_RICHCOMPARE    = 0x00000001<<5
+    Py_TPFLAGS_HAVE_WEAKREFS       = 0x00000001<<6
+    Py_TPFLAGS_HAVE_ITER           = 0x00000001<<7
+    Py_TPFLAGS_HAVE_CLASS          = 0x00000001<<8
+    Py_TPFLAGS_HAVE_INDEX          = 0x00000001<<17
+    Py_TPFLAGS_HAVE_NEWBUFFER      = 0x00000001<<21
+    Py_TPFLAGS_STRING_SUBCLASS     = 0x00000001<<27
+
+    # Python 3.0+ has only these:
+    Py_TPFLAGS_HEAPTYPE = 0x00000001<<9
+    Py_TPFLAGS_BASETYPE = 0x00000001<<10
+    Py_TPFLAGS_READY    = 0x00000001<<12
+    Py_TPFLAGS_READYING = 0x00000001<<13
+    Py_TPFLAGS_HAVE_GC  = 0x00000001<<14
+    Py_TPFLAGS_HAVE_VERSION_TAG  = 0x00000001<<18
+    Py_TPFLAGS_VALID_VERSION_TAG = 0x00000001<<19
+    Py_TPFLAGS_IS_ABSTRACT    = 0x00000001<<20
+    Py_TPFLAGS_INT_SUBCLASS   = 0x00000001<<23
+    Py_TPFLAGS_LONG_SUBCLASS  = 0x00000001<<24
+    Py_TPFLAGS_LIST_SUBCLASS  = 0x00000001<<25
+    Py_TPFLAGS_TUPLE_SUBCLASS = 0x00000001<<26
+    Py_TPFLAGS_BYTES_SUBCLASS = 0x00000001<<27
+    Py_TPFLAGS_UNICODE_SUBCLASS  = 0x00000001<<28
+    Py_TPFLAGS_DICT_SUBCLASS     = 0x00000001<<29
+    Py_TPFLAGS_BASE_EXC_SUBCLASS = 0x00000001<<30
+    Py_TPFLAGS_TYPE_SUBCLASS     = 0x00000001<<31
+
+    # only use this if we have the stackless extension
+    Py_TPFLAGS_HAVE_STACKLESS_EXTENSION_ = 0x00000003<<15
+
+    class PyMethodDef < FFI::Struct
+      layout ml_name:  :string,
+             ml_meth:  :pointer,
+             ml_flags: :int,
+             ml_doc:   :string   # may be NULL
+
+      def initialize(*args)
+        case args.length
+        when 3, 4
+          name, meth, flags, doc = *args
+          super()
+          self.ml_name = name
+          self[:ml_meth] = meth
+          self[:ml_flags] = flags
+          self.ml_doc = doc
+        else
+          super
+        end
+      end
+
+      def ml_name=(str)
+        @saved_name = FFI::MemoryPointer.from_string(str || '')
+        self.pointer.put_pointer(offset_of(:ml_name), @saved_name)
+      end
+
+      def ml_doc=(str)
+        @saved_doc = FFI::MemoryPointer.from_string(str || '')
+        self.pointer.put_pointer(offset_of(:ml_name), @saved_doc)
+      end
+    end
+
+    # ml_flags should be one of:
+    METH_VARARGS = 0x0001   # args are a tuple of arguments
+    METH_KEYWORDS = 0x0002  # two arguments: the varargs and the kwargs
+    METH_NOARGS = 0x0004    # no arguments (NULL argument pointer)
+    METH_O = 0x0008         # single argument (not wrapped in tuple)
+
+    # not sure when these are needed:
+    METH_CLASS = 0x0010 # for class methods
+    METH_STATIC = 0x0020 # for static methods
+
+    class PyGetSetDef < FFI::Struct
+      layout name:    :string,
+             get:     :pointer,
+             set:     :pointer,  # may be NULL for read-only members
+             doc:     :string,
+             closure: :pointer
+    end
+
+    class PyMemberDef < FFI::Struct
+      layout name:   :string,
+             type:   :int,
+             offset: :ssize_t,
+             flags:  :int,
+             doc:    :string
+
+      [:name, :doc].each do |field|
+        define_method(:"#{field}=") do |str|
+          saved_str = FFI::MemoryPointer.from_string(str)
+          instance_variable_set(:"@saved_#{field}", saved_str)
+          self.pointer.put_pointer(offset_of(field), saved_str)
+        end
+      end
+    end
+
+    class PyTypeObjectStruct < PyObjectStruct
+      layout ob_refcnt: :ssize_t,
+             ob_type:   PyTypeObjectStruct.by_ref,
+             ob_size:   :ssize_t,
+
+             tp_name: :string, # For printing, in format "<module>.<name>"
+
+             # For allocation
+             tp_basicsize: :ssize_t,
+             tp_itemsize: :ssize_t,
+
+             # Methods to implement standard operations
+
+             tp_dealloc: :pointer,
+             tp_print: :pointer,
+             tp_getattr: :pointer,
+             tp_setattr: :pointer,
+             tp_as_async: :pointer, # formerly known as tp_compare (Python 2) or tp_reserved (Python 3)
+             tp_repr: :pointer,
+
+             # Method suites for standard classes
+
+             tp_as_number: :pointer,
+             tp_as_sequence: :pointer,
+             tp_as_mapping: :pointer,
+
+             # More standard operations (here for binary compatibility)
+
+             tp_hash: :pointer,
+             tp_call: :pointer,
+             tp_str: :pointer,
+             tp_getattro: :pointer,
+             tp_setattro: :pointer,
+
+             # Functions to access object as input/output buffer
+             tp_as_buffer: :pointer,
+
+             # Flags to define presence of optional/expanded features
+             tp_flags: :ulong,
+
+             tp_doc: :string, # Documentation string
+
+             # Assigned meaning in release 2.0
+             # call function for all accessible objects
+             tp_traverse: :pointer,
+
+             # delete references to contained objects
+             tp_clear: :pointer,
+
+             # Assigned meaning in release 2.1
+             # rich comparisons
+             tp_richcompare: :pointer,
+
+             # weak reference enabler
+             tp_weaklistoffset: :ssize_t,
+
+             # Iterators
+             tp_iter: :pointer,
+             tp_iternext: :pointer,
+
+             # Attribute descriptor and subclassing stuff
+             tp_methods: PyMethodDef.by_ref,
+             tp_members: PyMemberDef.by_ref,
+             tp_getset: PyGetSetDef.by_ref,
+             tp_base: :pointer,
+             tp_dict: PyObjectStruct.by_ref,
+             tp_descr_get: :pointer,
+             tp_descr_set: :pointer,
+             tp_dictoffset: :ssize_t,
+             tp_init: :pointer,
+             tp_alloc: :pointer,
+             tp_new: :pointer,
+             tp_free: :pointer, # Low-level free-memory routine
+             tp_is_gc: :pointer, # For PyObject_IS_GC
+             tp_bases: PyObjectStruct.by_ref,
+             tp_mro: PyObjectStruct.by_ref, # method resolution order
+             tp_cache: PyObjectStruct.by_ref,
+             tp_subclasses: PyObjectStruct.by_ref,
+             tp_weaklist: PyObjectStruct.by_ref,
+             tp_del: :pointer,
+
+             # Type attribute cache version tag. Added in version 2.6
+             tp_version_tag: :uint,
+
+             tp_finalize: :pointer,
+
+             # The following members are only used for COUNT_ALLOCS builds of Python
+             tp_allocs: :ssize_t,
+             tp_frees: :ssize_t,
+             tp_maxalloc: :ssize_t,
+             tp_prev: :pointer,
+             tp_next: :pointer
+
+      def self.new(*args)
+        case args.length
+        when 0, 1
+          super
+        else
+          name, basic_size = *args
+          new.tap do |t|
+            # NOTE: Disable autorelease for avoiding SEGV occurrance in Python's GC collect function
+            #       at which the __new__ method object of this type object is freed.
+            t.pointer.autorelease = false
+
+            # PyVarObject_HEAD_INIT(&PyType_Type, 0)
+            t[:ob_refcnt] = 1
+            t[:ob_type] = LibPython.PyType_Type
+            t[:ob_size] = 0
+
+            t[:tp_basicsize] = basic_size
+            stackless_extension_flag = PyCall.has_stackless_extension ? Py_TPFLAGS_HAVE_STACKLESS_EXTENSION_ : 0
+            t[:tp_flags] = if PYTHON_VERSION >= '3'
+                             stackless_extension_flag | Py_TPFLAGS_HAVE_VERSION_TAG
+                           else
+                             Py_TPFLAGS_HAVE_GETCHARBUFFER |
+                               Py_TPFLAGS_HAVE_SEQUENCE_IN |
+                               Py_TPFLAGS_HAVE_INPLACEOPS |
+                               Py_TPFLAGS_HAVE_RICHCOMPARE |
+                               Py_TPFLAGS_HAVE_WEAKREFS |
+                               Py_TPFLAGS_HAVE_ITER |
+                               Py_TPFLAGS_HAVE_CLASS |
+                               stackless_extension_flag |
+                               Py_TPFLAGS_HAVE_INDEX
+                           end
+            t.tp_name = name
+            yield t if block_given?
+            t[:tp_new] = LibPython.find_symbol(:PyType_GenericNew) if t[:tp_new] == FFI::Pointer::NULL
+            raise PyError.fetch if LibPython.PyType_Ready(t) < 0
+            LibPython.Py_IncRef(t)
+          end
+        end
+      end
+
+      def tp_name=(str)
+        @saved_name = FFI::MemoryPointer.from_string(str)
+        self.pointer.put_pointer(offset_of(:tp_name), @saved_name)
+      end
+    end
+  end
+end

data/lib/pycall/libpython.rb

@@ -0,0 +1,12 @@
+module PyCall
+  module LibPython
+    require 'pycall/libpython/finder'
+
+    def self.handle
+      # NOTE: PyCall.init redefine this method.
+      #       See pycall/init.rb for the detail.
+      PyCall.init
+      handle
+    end
+  end
+end

data/lib/pycall/list.rb

@@ -0,0 +1,45 @@
+module PyCall
+  List = builtins.list
+  class List
+    register_python_type_mapping
+
+    include Enumerable
+
+    def include?(item)
+      LibPython::Helpers.sequence_contains(__pyptr__, item)
+    end
+
+    def length
+      PyCall.len(self)
+    end
+
+    def each
+      return enum_for unless block_given?
+      LibPython::Helpers.sequence_each(__pyptr__, &proc)
+      self
+    end
+
+    def <<(item)
+      append(item)
+    end
+
+    def push(*items)
+      items.each {|i| append(i) }
+    end
+
+    def sort
+      dup.sort!
+    end
+
+    def sort!
+      LibPython::Helpers.getattr(__pyptr__, :sort).__call__
+      self
+    end
+
+    def to_a
+      Array.new(length) {|i| self[i] }
+    end
+
+    alias to_ary to_a
+  end
+end

data/lib/pycall/pretty_print.rb

@@ -0,0 +1,9 @@
+require 'pycall'
+require 'pp'
+
+PyCall.init
+module PyCall
+  class PyPtr < BasicObject
+    include ::PP::ObjectMixin
+  end
+end

data/lib/pycall/pyerror.rb

@@ -0,0 +1,30 @@
+require 'pycall/error'
+
+module PyCall
+  class PyError < Error
+    def initialize(type, value, traceback)
+      @type = type
+      @value = value
+      @traceback = traceback
+      super("Exception occurred in Python")
+    end
+
+    attr_reader :type, :value, :traceback
+
+    def to_s
+      "#{type}: #{value}".tap do |msg|
+        if (strs = format_traceback)
+          msg << "\n"
+          strs.each {|s| msg << s }
+        end
+      end
+    end
+
+    private
+
+    def format_traceback
+      return nil if traceback.nil?
+      ::PyCall.import_module('traceback').format_tb(traceback)
+    end
+  end
+end

data/lib/pycall/pyobject_wrapper.rb

@@ -0,0 +1,212 @@
+require 'pycall/wrapper_object_cache'
+
+module PyCall
+  module PyObjectWrapper
+    attr_reader :__pyptr__
+
+    def self.extend_object(obj)
+      pyptr = obj.instance_variable_get(:@__pyptr__)
+      unless pyptr.kind_of? PyPtr
+        raise TypeError, "@__pyptr__ should have PyCall::PyPtr object"
+      end
+      super
+    end
+
+    OPERATOR_METHOD_NAMES = {
+      :+  => :__add__,
+      :-  => :__sub__,
+      :*  => :__mul__,
+      :/  => :__truediv__,
+      :%  => :__mod__,
+      :** => :__pow__,
+      :<< => :__lshift__,
+      :>> => :__rshift__,
+      :&  => :__and__,
+      :^  => :__xor__,
+      :|  => :__or__
+    }.freeze
+
+    def method_missing(name, *args)
+      name_str = name.to_s if name.kind_of?(Symbol)
+      name_str.chop! if name_str.end_with?('=')
+      case name
+      when *OPERATOR_METHOD_NAMES.keys
+        op_name = OPERATOR_METHOD_NAMES[name]
+        if LibPython::Helpers.hasattr?(__pyptr__, op_name)
+          LibPython::Helpers.define_wrapper_method(self, op_name)
+          singleton_class.__send__(:alias_method, name, op_name)
+          return self.__send__(name, *args)
+        end
+      else
+        if LibPython::Helpers.hasattr?(__pyptr__, name_str)
+          LibPython::Helpers.define_wrapper_method(self, name)
+          return self.__send__(name, *args)
+        end
+      end
+      super
+    end
+
+    def respond_to_missing?(name, include_private)
+      return true if LibPython::Helpers.hasattr?(__pyptr__, name)
+      super
+    end
+
+    def kind_of?(cls)
+      case cls
+      when PyTypeObjectWrapper
+        __pyptr__.kind_of?(cls.__pyptr__)
+      else
+        super
+      end
+    end
+
+    [:==, :!=, :<, :<=, :>, :>=].each do |op|
+      class_eval("#{<<-"begin;"}\n#{<<-"end;"}", __FILE__, __LINE__+1)
+      begin;
+        def #{op}(other)
+          case other
+          when PyObjectWrapper
+            LibPython::Helpers.compare(:#{op}, __pyptr__, other.__pyptr__)
+          else
+            other = Conversion.from_ruby(other)
+            LibPython::Helpers.compare(:#{op}, __pyptr__, other)
+          end
+        end
+      end;
+    end
+
+    def [](*key)
+      LibPython::Helpers.getitem(__pyptr__, key)
+    end
+
+    def []=(*key, value)
+      LibPython::Helpers.setitem(__pyptr__, key, value)
+    end
+
+    def call(*args)
+      LibPython::Helpers.call_object(__pyptr__, *args)
+    end
+
+    class SwappedOperationAdapter
+      def initialize(obj)
+        @obj = obj
+      end
+
+      attr_reader :obj
+
+      def +(other)
+        other.__radd__(self.obj)
+      end
+
+      def -(other)
+        other.__rsub__(self.obj)
+      end
+
+      def *(other)
+        other.__rmul__(self.obj)
+      end
+
+      def /(other)
+        other.__rtruediv__(self.obj)
+      end
+
+      def %(other)
+        other.__rmod__(self.obj)
+      end
+
+      def **(other)
+        other.__rpow__(self.obj)
+      end
+
+      def <<(other)
+        other.__rlshift__(self.obj)
+      end
+
+      def >>(other)
+        other.__rrshift__(self.obj)
+      end
+
+      def &(other)
+        other.__rand__(self.obj)
+      end
+
+      def ^(other)
+        other.__rxor__(self.obj)
+      end
+
+      def |(other)
+        other.__ror__(self.obj)
+      end
+    end
+
+    def coerce(other)
+      [SwappedOperationAdapter.new(other), self]
+    end
+
+    def dup
+      super.tap do |duped|
+        copied = PyCall.import_module('copy').copy(__pyptr__)
+        copied = copied.__pyptr__ if copied.kind_of? PyObjectWrapper
+        duped.instance_variable_set(:@__pyptr__, copied)
+      end
+    end
+
+    def inspect
+      PyCall.builtins.repr(__pyptr__)
+    end
+
+    def to_s
+      LibPython::Helpers.str(__pyptr__)
+    end
+
+    def to_i
+      LibPython::Helpers.call_object(PyCall::builtins.int.__pyptr__, __pyptr__)
+    end
+
+    def to_f
+      LibPython::Helpers.call_object(PyCall::builtins.float.__pyptr__, __pyptr__)
+    end
+  end
+
+  module_function
+
+  class WrapperModuleCache < WrapperObjectCache
+    def initialize
+      super(LibPython::API::PyModule_Type)
+    end
+
+    def check_wrapper_object(wrapper_object)
+      unless wrapper_object.kind_of?(Module) && wrapper_object.kind_of?(PyObjectWrapper)
+        raise TypeError, "unexpected type #{wrapper_object.class} (expected Module extended by PyObjectWrapper)"
+      end
+    end
+
+    def self.instance
+      @instance ||= self.new
+    end
+  end
+
+  private_constant :WrapperModuleCache
+
+  def wrap_module(pymodptr)
+    check_ismodule(pymodptr)
+    WrapperModuleCache.instance.lookup(pymodptr) do
+      Module.new do |mod|
+        mod.instance_variable_set(:@__pyptr__, pymodptr)
+        mod.extend PyObjectWrapper
+      end
+    end
+  end
+
+  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)
+    raise TypeError, "PyType object is required"
+  end
+
+  def check_ismodule(pyptr)
+    return if pyptr.kind_of? LibPython::API::PyModule_Type
+    raise TypeError, "PyModule object is required"
+  end
+end

data/lib/pycall/python/PyCall/__init__.py

@@ -0,0 +1 @@
+

data/lib/pycall/python/PyCall/six.py

@@ -0,0 +1,23 @@
+import sys
+
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+  import builtins
+else:
+  import __builtin__ as builtins
+
+if PY3:
+  exec_ = getattr(builtins, 'exec')
+else:
+  def exec_(_code_, _globals_=None, _locals_=None):
+    """Execute code in a namespace."""
+    if _globals_ is None:
+      frame = sys._getframe(1)
+      _globals_ = frame.f_globals
+      if _locals_ is None:
+        _locals_ = frame.f_locals
+      del frame
+    elif _locals_ is None:
+      _locals_ = _globals_
+    exec("""exec _code_ in _globals_, _locals_""")

data/lib/pycall/python/investigator.py

@@ -0,0 +1,7 @@
+from distutils.sysconfig import get_config_var
+import sys
+for var in ('executable', 'exec_prefix', 'prefix'):
+  print(var + ': ' + str(getattr(sys, var)))
+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)))

data/lib/pycall/pytypeobject_wrapper.rb

@@ -0,0 +1,90 @@
+require 'pycall/pyobject_wrapper'
+
+module PyCall
+  module PyTypeObjectWrapper
+    include PyObjectWrapper
+
+    def self.extend_object(cls)
+      unless cls.kind_of? Class
+        raise TypeError, "PyTypeObjectWrapper cannot extend non-class objects"
+      end
+      pyptr = cls.instance_variable_get(:@__pyptr__)
+      unless pyptr.kind_of? PyTypePtr
+        raise TypeError, "@__pyptr__ should have PyCall::PyTypePtr object"
+      end
+      super
+      cls.include PyObjectWrapper
+    end
+
+    def inherited(subclass)
+      subclass.instance_variable_set(:@__pyptr__, __pyptr__)
+    end
+
+    def new(*args)
+      wrap_pyptr(LibPython::Helpers.call_object(__pyptr__, *args))
+    end
+
+    def wrap_pyptr(pyptr)
+      return pyptr if pyptr.kind_of? self
+      pyptr = pyptr.__pyptr__ if pyptr.kind_of? PyObjectWrapper
+      unless pyptr.kind_of? PyPtr
+        raise TypeError, "unexpected argument type #{pyptr.class} (expected PyCall::PyPtr)"
+      end
+      unless pyptr.kind_of? __pyptr__
+        raise TypeError, "unexpected argument Python type #{pyptr.__ob_type__.__tp_name__} (expected #{__pyptr__.__tp_name__})"
+      end
+      allocate.tap do |obj|
+        obj.instance_variable_set(:@__pyptr__, pyptr)
+      end
+    end
+
+    def ===(other)
+      case other
+      when PyObjectWrapper
+        __pyptr__ === other.__pyptr__
+      when PyPtr
+        __pyptr__ === other
+      else
+        super
+      end
+    end
+
+    private
+
+    def register_python_type_mapping
+      PyCall::Conversion.register_python_type_mapping(__pyptr__, self)
+    end
+  end
+
+  module_function
+
+  class WrapperClassCache < WrapperObjectCache
+    def initialize
+      types = [LibPython::API::PyType_Type]
+      types << LibPython::API::PyClass_Type if defined? LibPython::API::PyClass_Type
+      super(*types)
+    end
+
+    def check_wrapper_object(wrapper_object)
+      unless wrapper_object.kind_of?(Class) && wrapper_object.kind_of?(PyTypeObjectWrapper)
+        raise TypeError, "unexpected type #{wrapper_object.class} (expected Class extended by PyTypeObjectWrapper)"
+      end
+    end
+
+    def self.instance
+      @instance ||= self.new
+    end
+  end
+
+  private_constant :WrapperClassCache
+
+  def wrap_class(pytypeptr)
+    check_isclass(pytypeptr)
+    WrapperClassCache.instance.lookup(pytypeptr) do
+      Class.new do |cls|
+        cls.instance_variable_set(:@__pyptr__, pytypeptr)
+        cls.extend PyTypeObjectWrapper
+      end
+    end
+  end
+end