rubypython-raspi 0.1.0

data/Rakefile

@@ -0,0 +1,108 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :doofus
+Hoe.plugin :gemspec
+Hoe.plugin :rubyforge
+Hoe.plugin :git
+Hoe.plugin :hg
+
+Hoe.spec 'rubypython' do
+  self.rubyforge_name = self.name
+
+  developer('Steeve Morin', 'swiuzzz+rubypython@gmail.com')
+  developer('Austin Ziegler', 'austin@rubyforge.org')
+  developer('Zach Raines', 'raineszm+rubypython@gmail.com')
+
+  self.remote_rdoc_dir = 'rdoc'
+  self.rsync_args << ' --exclude=statsvn/'
+
+  self.history_file = 'History.rdoc'
+  self.readme_file = 'README.rdoc'
+  self.extra_rdoc_files = FileList["*.rdoc"].to_a
+
+  self.extra_deps << ['ffi', '~> 1.0.7']
+  self.extra_deps << ['blankslate', '>= 2.1.2.3']
+
+  self.extra_dev_deps << ['rspec', '~> 2.0']
+  self.extra_dev_deps << ['tilt', '~> 1.0']
+
+  self.spec_extras[:requirements]  = [ "Python, ~> 2.4" ]
+end
+
+namespace :website do
+  desc "Build the website files."
+  task :build => [ "website/index.html" ]
+
+  deps = FileList["website/**/*"].exclude { |f| File.directory? f }
+  deps.include(*%w(Rakefile))
+  deps.include(*FileList["*.rdoc"].to_a)
+  deps.exclude(*%w(website/index.html website/images/*))
+
+  file "website/index.html" => deps do |t|
+    require 'tilt'
+    require 'rubypython'
+
+    puts "Generating #{t.name}…"
+
+    # Let's modify the rdoc for presenation purposes.
+    body_rdoc = File.read("README.rdoc")
+
+    contrib = File.read("Contributors.rdoc")
+    body_rdoc.gsub!(/^:include: Contributors.rdoc/, contrib)
+
+    license = File.read("License.rdoc")
+    body_rdoc.sub!(/^:include: License.rdoc/, license)
+    toc_elements = body_rdoc.scan(/^(=+) (.*)$/)
+    toc_elements.map! { |e| [ e[0].count('='), e[1] ] }
+    body_rdoc.gsub!(/^(=.*)/) { "#{$1.downcase}" }
+    body = Tilt::RDocTemplate.new(nil) { body_rdoc }.render
+
+    title = nil
+    body.gsub!(%r{<h1>(.*)</h1>}) { title = $1; "" }
+
+    toc_elements = toc_elements.select { |e| e[0].between?(2, 3) }
+
+    last_level = 0
+    toc = ""
+
+    toc_elements.each do |element|
+      level, text = *element
+      ltext = text.downcase
+      id = text.downcase.gsub(/[^a-z]+/, '-')
+
+      body.gsub!(%r{<h#{level}>#{ltext}</h#{level}>}) {
+        %Q(<h#{level} id="#{id}">#{ltext}</h#{level}>)
+      }
+
+      if last_level != level
+        if level > last_level
+          toc << "<ol>"
+        else
+          toc << "</li></ol></li>"
+        end
+
+        last_level = level
+      end
+
+      toc << %Q(<li><a href="##{id}">#{text}</a>)
+    end
+    toc << "</li></ol>"
+
+    template = Tilt.new("website/index.rhtml", :trim => "<>%")
+    context = {
+      :title => title,
+      :toc => toc,
+      :body => body,
+      :download => "http://rubyforge.org/frs/?group_id=6737",
+      :version => RubyPython::VERSION,
+      :modified => Time.now
+    }
+    File.open(t.name, "w") { |f| f.write template.render(self, context) } end
+end
+
+task "docs" => "website:build"
+
+# vim: syntax=ruby

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/lib/rubypython.rb

@@ -0,0 +1,284 @@
+# RubyPython is a bridge between the Ruby and \Python interpreters. It
+# embeds a \Python interpreter in the Ruby application's process using FFI
+# and provides a means for wrapping, converting, and calling \Python objects
+# and methods.
+#
+# == Usage
+# The \Python interpreter must be started before the RubyPython bridge is
+# functional. The user can either manually manage the running of the
+# interpreter as shown below, or use the +RubyPython.run+ or
+# +RubyPython.session+ methods to automatically start and stop the
+# interpreter.
+#
+#   RubyPython.start
+#   cPickle = RubyPython.import "cPickle"
+#   puts cPickle.dumps("RubyPython is awesome!").rubify
+#   RubyPython.stop
+module RubyPython
+  VERSION = '0.6'
+end
+
+require 'rubypython/blankobject'
+require 'rubypython/interpreter'
+require 'rubypython/python'
+require 'rubypython/pythonerror'
+require 'rubypython/pyobject'
+require 'rubypython/rubypyproxy'
+require 'rubypython/pymainclass'
+require 'rubypython/pygenerator'
+require 'rubypython/tuple'
+require 'thread'
+
+module RubyPython
+  class << self
+    ##
+    # :attr_accessor:
+    # Controls whether RubyPython is operating in <em>Proxy Mode</em> or
+    # <em>Legacy Mode</em>. This behavioural difference is deprecated as of
+    # RubyPython 0.6 and will be removed in a subsequent release.
+    #
+    # === Proxy Mode
+    # By default, +legacy_mode+ is +false+, meaning that any object returned
+    # from a \Python function call will be wrapped in a Ruby-Python proxy
+    # (an instance of +RubyPyProxy+ or one of its subclasses). This allows
+    # \Python method calls to be forwarded to the \Python object, even if it
+    # would otherwise be a native Ruby object.
+    #
+    #   RubyPython.session do
+    #     string = RubyPython.import 'string'
+    #     ascii_letters = string.ascii_letters
+    #     puts ascii_letters.isalpha # => True
+    #     puts ascii_letters.rubify.isalpha # throws NoMethodError
+    #   end
+    #
+    # === Legacy Mode
+    # If +legacy_mode+ is +true+, RubyPython automatically tries to convert
+    # returned objects to native Ruby object types. If there is no such
+    # conversion, the object remains wrapped in +RubyPyProxy+. This
+    # behaviour is the same as RubyPython 0.2 and earlier. This mode is
+    # deprecated as of RubyPython 0.6 and will be removed.
+    #
+    #   RubyPython.legacy_mode = true
+    #   RubyPython.session do
+    #     string = RubyPython.import 'string'
+    #     ascii_letters = string.ascii_letters
+    #     puts ascii_letters.isalpha # throws NoMethodError
+    #   end
+    def legacy_mode=(value)
+      warn_legacy_mode_deprecation unless defined? @legacy_mode
+      @legacy_mode = value
+    end
+
+    def legacy_mode
+      unless defined? @legacy_mode
+        warn_legacy_mode_deprecation
+        @legacy_mode = nil
+      end
+      @legacy_mode
+    end
+
+    def legacy_mode?
+      @legacy_mode = nil unless defined? @legacy_mode
+      @legacy_mode
+    end
+    private :legacy_mode?
+
+    def warn_legacy_mode_deprecation
+      warn "RubyPython's Legacy Mode is deprecated and will be removed after version #{VERSION}."
+    end
+    private :warn_legacy_mode_deprecation
+
+    ## Starts the \Python interpreter. One of +RubyPython.start+,
+    # RubyPython.session+, or +RubyPython.run+ must be run before using any
+    # \Python code. Returns +true+ if the interpreter was started; +false+
+    # otherwise.
+    #
+    # [options] Configures the interpreter prior to starting it. Principally
+    #           used to provide an alternative \Python interpreter to start.
+    #
+    # With no options provided:
+    #   RubyPython.start
+    #   sys = RubyPython.import 'sys'
+    #   p sys.version # => "2.6.6"
+    #   RubyPython.stop
+    #
+    # With an alternative \Python executable:
+    #   RubyPython.start(:python_exe => 'python2.7')
+    #   sys = RubyPython.import 'sys'
+    #   p sys.version # => "2.7.1"
+    #   RubyPython.stop
+    def start(options = {})
+      Mutex.new.synchronize do
+        # Has the Runtime interpreter been defined?
+        if self.const_defined?(:Runtime)
+          # If this constant is defined, then yes it is. Since it is, let's
+          # see if we should print a warning to the user.
+          unless Runtime == options
+            warn "The Python interpreter has already been loaded from #{Runtime.python} and cannot be changed in this process. Continuing with the current runtime."
+          end
+        else
+          interp = RubyPython::Interpreter.new(options)
+          if interp.valid?
+            self.const_set(:Runtime, interp)
+          else
+            raise RubyPython::InvalidInterpreter, "An invalid interpreter was specified."
+          end
+        end
+
+        unless defined? RubyPython::Python.ffi_libraries
+          Runtime.__send__(:infect!, RubyPython::Python)
+        end
+      end
+
+      return false if RubyPython::Python.Py_IsInitialized != 0
+      RubyPython::Python.Py_Initialize
+      notify :start
+      true
+    end
+
+    # Stops the \Python interpreter if it is running. Returns +true+ if the
+    # intepreter is stopped. All wrapped \Python objects are invalid after
+    # invocation of this method. If you need the values within the \Python
+    # proxy objects, be sure to call +RubyPyProxy#rubify+ on them.
+    def stop
+      if defined? Python.Py_IsInitialized and Python.Py_IsInitialized != 0
+        Python.Py_Finalize
+        notify :stop
+        true
+      else
+        false
+      end
+    end
+
+    # Import a \Python module into the interpreter and return a proxy object
+    # for it.
+    #
+    # This is the preferred way to gain access to \Python objects.
+    #
+    # [mod_name] The name of the module to import.
+    def import(mod_name)
+      if defined? Python.Py_IsInitialized and Python.Py_IsInitialized != 0
+        pModule = Python.PyImport_ImportModule mod_name
+        raise PythonError.handle_error if PythonError.error?
+        pymod = PyObject.new pModule
+        RubyPyModule.new(pymod)
+      else
+        raise "Python has not been started."
+      end
+    end
+
+    # Starts the \Python interpreter (optionally with options) and +yields+
+    # to the provided block. When the block exits for any reason, the
+    # \Python interpreter is stopped automatically.
+    #
+    # The last executed expression of the block is returned. Be careful that
+    # the last expression of the block does not return a RubyPyProxy object,
+    # because the proxy object will be invalidated when the interpreter is
+    # stopped.
+    #
+    # [options] Configures the interpreter prior to starting it. Principally
+    #           used to provide an alternative \Python interpreter to start.
+    #
+    # *NOTE*: In the current version of RubyPython, it _is_ possible to change
+    # \Python interpreters in a single Ruby process execution, but it is
+    # *strongly* discouraged as this may lead to segmentation faults. This
+    # feature is highly experimental and may be disabled in the future.
+    #
+    # :call-seq:
+    # session(options = {}) { block to execute }
+    def session(options = {})
+      start(options)
+      yield
+    ensure
+      stop
+    end
+
+    # Starts the \Python interpreter (optionally with options) and executes
+    # the provided block in the RubyPython module scope. When the block
+    # exits for any reason, the \Python interpreter is stopped
+    # automatically.
+    #
+    # The last executed expression of the block is returned. Be careful that
+    # the last expression of the block does not return a RubyPyProxy object,
+    # because the proxy object will be invalidated when the interpreter is
+    # stopped.
+    #
+    # [options] Configures the interpreter prior to starting it. Principally
+    #           used to provide an alternative \Python interpreter to start.
+    #
+    # *NOTE*: In the current version of RubyPython, it _is_ possible to
+    # change \Python interpreters in a single Ruby process execution, but it
+    # is *strongly* discouraged as this may lead to segmentation faults.
+    # This feature is highly experimental and may be disabled in the future.
+    #
+    # :call-seq:
+    # run(options = {}) { block to execute in RubyPython context }
+    def run(options = {}, &block)
+      start(options)
+      self.module_eval(&block)
+    ensure
+      stop
+    end
+
+    # Starts the \Python interpreter for a
+    # {virtualenv}[http://pypi.python.org/pypi/virtualenv] virtual
+    # environment. Returns +true+ if the interpreter was started.
+    #
+    # [virtualenv]  The root path to the virtualenv-installed \Python
+    #               interpreter.
+    #
+    #   RubyPython.start_from_virtualenv('/path/to/virtualenv')
+    #   sys = RubyPython.import 'sys'
+    #   p sys.version # => "2.7.1"
+    #   RubyPython.stop
+    #
+    # *NOTE*: In the current version of RubyPython, it _is_ possible to
+    # change \Python interpreters in a single Ruby process execution, but it
+    # is *strongly* discouraged as this may lead to segmentation faults.
+    # This feature is highly experimental and may be disabled in the future.
+    def start_from_virtualenv(virtualenv)
+      result = start(:python_exe => File.join(virtualenv, "bin", "python"))
+      activate_virtualenv
+      result
+    end
+
+    # Returns an object describing the active Python interpreter. Returns
+    # +nil+ if there is no active interpreter.
+    def python
+      if self.const_defined? :Runtime
+        self::Runtime
+      else
+        nil
+      end
+    end
+
+    # Used to activate the virtualenv.
+    def activate_virtualenv
+      imp = import("imp")
+      imp.load_source("activate_this",
+                      File.join(File.dirname(RubyPython::Runtime.python),
+                      "activate_this.py"))
+    end
+    private :activate_virtualenv
+
+    def add_observer(object)
+      @observers ||= []
+      @observers << object
+      true
+    end
+    private :add_observer
+
+    def notify(status)
+      @observers ||= []
+      @observers.each do |o|
+        next if nil === o
+        o.__send__ :python_interpreter_update, status
+      end
+    end
+    private :notify
+  end
+
+  add_observer PyMain
+  add_observer Operators
+  add_observer PyObject::AutoPyPointer
+end

data/lib/rubypython/blankobject.rb

@@ -0,0 +1,23 @@
+require 'blankslate'
+
+# This document is the basis of the RubyPyProxy precisely because it hides
+# the implementation of so many things that should be forwarded on to the
+# Python object. This class is for internal use only.
+#
+# Note that in Ruby 1.9, BasicObject might be a better choice, but there are
+# some decisions made in the rest of the library that make this harder. I
+# don't see a clean way to integrate both Ruby 1.8 and 1.9 support for this.
+class RubyPython::BlankObject < ::BlankSlate #:nodoc:
+  class << self
+    def hide(name)
+      if instance_methods.include?(name) and
+        name.to_s !~ /^(__|instance_eval|object_id)/
+          @hidden_methods ||= {}
+        @hidden_methods[name.to_sym] = instance_method(name)
+        undef_method name
+      end
+    end
+  end
+
+  instance_methods.each { |m| hide(m) }
+end

data/lib/rubypython/conversion.rb

@@ -0,0 +1,286 @@
+require 'rubypython/python'
+require 'rubypython/macros'
+
+# Acts as a namespace for methods to bidirectionally convert between native
+# Ruby types and native \Python types. Unsupported conversions raise
+# UnsupportedConversion.
+#
+# The methods in this module should be considered internal implementation to
+# RubyPython as they all return FFI pointers to \Python objects.
+module RubyPython::Conversion
+  # Raised when RubyPython does not know how to convert an object from
+  # \Python to Ruby or vice versa.
+  class UnsupportedConversion < Exception; end
+
+  # Convert a Ruby string to a \Python string. Returns an FFI::Pointer to
+  # a PyStringObject.
+  def self.rtopString(rString)
+    size = rString.respond_to?(:bytesize) ? rString.bytesize : rString.size
+    RubyPython::Python.PyString_FromStringAndSize(rString, size)
+  end
+
+  # Convert a Ruby Array to \Python List. Returns an FFI::Pointer to
+  # a PyListObject.
+  def self.rtopArrayToList(rArray)
+    size = rArray.length
+    pList = RubyPython::Python.PyList_New size
+    rArray.each_with_index do |el, i|
+      RubyPython::Python.PyList_SetItem pList, i, rtopObject(el)
+    end
+    pList
+  end
+
+  # Convert a Ruby Array (including the subclass RubyPython::Tuple) to
+  # \Python \tuple. Returns an FFI::Pointer to a PyTupleObject.
+  def self.rtopArrayToTuple(rArray)
+    pList = rtopArrayToList(rArray)
+    pTuple = RubyPython::Python.PySequence_Tuple(pList)
+    RubyPython::Python.Py_DecRef(pList)
+    pTuple
+  end
+
+  # Convert a Ruby Hash to a \Python Dict. Returns an FFI::Pointer to a
+  # PyDictObject.
+  def self.rtopHash(rHash)
+    pDict = RubyPython::Python.PyDict_New
+    rHash.each do |k,v|
+      RubyPython::Python.PyDict_SetItem pDict, rtopObject(k, key = true),
+        rtopObject(v)
+    end
+    pDict
+  end
+
+  # Convert a Ruby Fixnum to a \Python Int. Returns an FFI::Pointer to a
+  # PyIntObject.
+  def self.rtopFixnum(rNum)
+    RubyPython::Python.PyInt_FromLong(rNum)
+  end
+
+  # Convert a Ruby Bignum to a \Python Long. Returns an FFI::Pointer to a
+  # PyLongObject.
+  def self.rtopBigNum(rNum)
+    RubyPython::Python.PyLong_FromLong(rNum)
+  end
+
+  # Convert a Ruby float to a \Python Float. Returns an FFI::Pointer to a
+  # PyFloatObject.
+  def self.rtopFloat(rNum)
+    RubyPython::Python.PyFloat_FromDouble(rNum)
+  end
+
+  # Returns a \Python False value (equivalent to Ruby's +false+). Returns an
+  # FFI::Pointer to Py_ZeroStruct.
+  def self.rtopFalse
+    RubyPython::Macros.Py_RETURN_FALSE
+  end
+
+  # Returns a \Python True value (equivalent to Ruby's +true+). Returns an
+  # FFI::Pointer to Py_TrueStruct.
+  def self.rtopTrue
+    RubyPython::Macros.Py_RETURN_TRUE
+  end
+
+  # Returns a \Python None value (equivalent to Ruby's +nil+). Returns an
+  # FFI::Pointer to Py_NoneStruct.
+  def self.rtopNone
+    RubyPython::Macros.Py_RETURN_NONE
+  end
+
+  # Convert a Ruby Symbol to a \Python String. Returns an FFI::Pointer to a
+  # PyStringObject.
+  def self.rtopSymbol(rSymbol)
+    RubyPython::Python.PyString_FromString rSymbol.to_s
+  end
+
+  # Convert a Ruby Proc to a \Python Function. Returns an FFI::Pointer to a
+  # PyCFunction.
+  def self.rtopFunction(rObj)
+    proc = FFI::Function.new(:pointer, [:pointer, :pointer]) do |p_self, p_args|
+      retval = rObj.call(*ptorTuple(p_args))
+      pObject = retval.is_a?(RubyPython::RubyPyProxy) ? retval.pObject : RubyPython::PyObject.new(retval)
+
+      # make sure the refcount is >1 when pObject is destroyed
+      pObject.xIncref
+      pObject.pointer
+    end
+
+    defn = RubyPython::Python::PyMethodDef.new
+    defn[:ml_name] = FFI::MemoryPointer.from_string("RubyPython::Proc::%s" % rObj.object_id)
+    defn[:ml_meth] = proc
+    defn[:ml_flags] = RubyPython::Python::METH_VARARGS
+    defn[:ml_doc] = nil
+
+    return RubyPython::Python.PyCFunction_New(defn, nil)
+  end
+
+  # This will attempt to convert a Ruby object to an equivalent \Python
+  # native type. Returns an FFI::Pointer to a \Python object (the
+  # appropriate Py…Object C structure). If the conversion is unsuccessful,
+  # will raise UnsupportedConversion.
+  #
+  # [rObj]    A native Ruby object.
+  # [is_key]  Set to +true+ if the provided Ruby object will be used as a
+  #           key in a \Python +dict+. (This primarily matters for Array
+  #           conversion.)
+  def self.rtopObject(rObj, is_key = false)
+    case rObj
+    when String
+      rtopString rObj
+    when RubyPython::Tuple
+      rtopArrayToTuple rObj
+    when Array
+      # If this object is going to be used as a hash key we should make it a
+      # tuple instead of a list
+      if is_key
+        rtopArrayToTuple rObj
+      else
+        rtopArrayToList rObj
+      end
+    when Hash
+      rtopHash rObj
+    when Fixnum
+      rtopFixnum rObj
+    when Bignum
+      rtopBignum rObj
+    when Float
+      rtopFloat rObj
+    when true
+      rtopTrue
+    when false
+      rtopFalse
+    when Symbol
+      rtopSymbol rObj
+    when Proc, Method
+      if RubyPython.legacy_mode
+        raise UnsupportedConversion.new("Callbacks are not supported in Legacy Mode.")
+      end
+      rtopFunction rObj
+    when Method
+      rtopFunction rObj
+    when nil
+      rtopNone
+    when RubyPython::PyObject
+      rObj.pointer
+    else
+      raise UnsupportedConversion.new("Unsupported type #{rObj.class} for conversion.")
+    end
+  end
+
+  # Convert an FFI::Pointer to a \Python String (PyStringObject) to a Ruby
+  # String.
+  def self.ptorString(pString)
+    strPtr  = FFI::MemoryPointer.new(:pointer)
+    sizePtr = FFI::MemoryPointer.new(:ssize_t)
+
+    RubyPython::Python.PyString_AsStringAndSize(pString, strPtr, sizePtr)
+
+    size = case FFI.find_type(:ssize_t)
+           when FFI.find_type(:long)
+             sizePtr.read_long
+           when FFI.find_type(:int)
+             sizePtr.read_int
+           when FFI.find_type(:long_long)
+             sizePtr.read_long_long
+           else
+             nil
+           end
+
+    strPtr.read_pointer.read_string(size)
+  end
+
+  # Convert an FFI::Pointer to a \Python List (PyListObject) to a Ruby
+  # Array.
+  def self.ptorList(pList)
+    rb_array = []
+    list_size = RubyPython::Python.PyList_Size(pList)
+
+    list_size.times do |i|
+      element = RubyPython::Python.PyList_GetItem(pList, i)
+      # PyList_GetItem returns borrowed ref
+      RubyPython::Python.Py_IncRef element
+      rObject = ptorObject(element)
+      rb_array.push rObject
+    end
+
+    rb_array
+  end
+
+  # Convert an FFI::Pointer to a \Python Int (PyIntObject) to a Ruby Fixnum.
+  def self.ptorInt(pNum)
+    RubyPython::Python.PyInt_AsLong(pNum)
+  end
+
+  # Convert an FFI::Pointer to a \Python Long (PyLongObject) to a Ruby
+  # Fixnum. This version does not do overflow checking, but probably should.
+  def self.ptorLong(pNum)
+    RubyPython::Python.PyLong_AsLong(pNum)
+    # TODO Overflow Checking
+  end
+
+  # Convert an FFI::Pointer to a \Python Float (PyFloatObject) to a Ruby
+  # Float.
+  def self.ptorFloat(pNum)
+    RubyPython::Python.PyFloat_AsDouble(pNum)
+  end
+
+  # Convert an FFI::Pointer to a \Python Tuple (PyTupleObject) to an
+  # instance of RubyPython::Tuple, a subclass of the Ruby Array class.
+  def self.ptorTuple(pTuple)
+    pList = RubyPython::Python.PySequence_List pTuple
+    rArray = ptorList pList
+    RubyPython::Python.Py_DecRef pList
+    RubyPython::Tuple.tuple(rArray)
+  end
+
+  # Convert an FFI::Pointer to a \Python Dictionary (PyDictObject) to a Ruby
+  # Hash.
+  def self.ptorDict(pDict)
+    rb_hash = {}
+
+    pos = FFI::MemoryPointer.new :ssize_t
+    pos.write_int 0
+    key = FFI::MemoryPointer.new :pointer
+    val = FFI::MemoryPointer.new :pointer
+
+    while RubyPython::Python.PyDict_Next(pDict, pos, key, val) != 0
+      pKey = key.read_pointer
+      pVal = val.read_pointer
+      rKey = ptorObject(pKey)
+      rVal = ptorObject(pVal)
+      rb_hash[rKey] = rVal
+    end
+
+    rb_hash
+  end
+
+  # Converts a pointer to a \Python object into a native Ruby type, if
+  # possible. If the conversion cannot be done, the Python object will be
+  # returned unmodified.
+  #
+  # [pObj]  An FFI::Pointer to a \Python object.
+  def self.ptorObject(pObj)
+    if RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyString_Type.to_ptr) != 0
+      ptorString pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyList_Type.to_ptr) != 0
+      ptorList pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyInt_Type.to_ptr) != 0
+      ptorInt pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyLong_Type.to_ptr) != 0
+      ptorLong pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyFloat_Type.to_ptr) != 0
+      ptorFloat pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyTuple_Type.to_ptr) != 0
+      ptorTuple pObj
+    elsif RubyPython::Macros.PyObject_TypeCheck(pObj, RubyPython::Python.PyDict_Type.to_ptr) != 0
+      ptorDict pObj
+    elsif pObj == RubyPython::Macros.Py_True
+      true
+    elsif pObj == RubyPython::Macros.Py_False
+      false
+    elsif pObj == RubyPython::Macros.Py_None
+      nil
+    else
+      pObj
+    end
+  end
+end