pycall 1.0.1-x64-mingw32

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

data/lib/pycall/set.rb

@@ -0,0 +1,19 @@
+module PyCall
+  class Set
+    include PyObjectWrapper
+
+    def initialize(pyobj)
+      super(pyobj)
+    end
+
+    def size
+      LibPython.PySet_Size(__pyobj__)
+    end
+
+    alias length size
+
+    def include?(obj)
+      1 == LibPython.PySet_Contains(__pyobj__, Conversions.from_ruby(obj))
+    end
+  end
+end