rubypython-raspi 0.1.0

data/lib/rubypython/python.rb

@@ -0,0 +1,195 @@
+require 'ffi'
+require 'thread'
+require 'rubypython/interpreter'
+
+module RubyPython
+  # This module will hold the loaded RubyPython interpreter.
+  module Python #:nodoc: all
+  end
+end
+
+class RubyPython::Interpreter
+  # Infects the provided module with the Python FFI. Once a single module
+  # has been infected, the #infect! method is removed from
+  # RubyPython::Interpreter.
+  def infect!(mod)
+    Mutex.new.synchronize do
+      self.class.class_eval do
+        undef :infect!
+      end
+
+      mod.extend FFI::Library
+      # FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL
+      mod.ffi_lib_flags :lazy, :global
+      mod.ffi_lib self.library
+
+      # This class is a little bit of a hack to extract the address of
+      # global structs. If someone knows a better way please let me know.
+      mod.module_eval do
+        self.const_set :DummyStruct, Class.new(FFI::Struct)
+        self::DummyStruct.layout :dummy_var, :int
+
+        self.const_set(:PY_FILE_INPUT, 257)
+        self.const_set(:PY_EVAL_INPUT, 258)
+        self.const_set(:METH_VARARGS, 0x0001)
+
+        # Function methods & constants
+        attach_function :PyCFunction_New, [:pointer, :pointer], :pointer
+        callback :PyCFunction, [:pointer, :pointer], :pointer
+
+        attach_function :PyRun_String, [:string, :int, :pointer, :pointer], :pointer
+        attach_function :PyRun_SimpleString, [:string], :pointer
+        attach_function :Py_CompileString, [:string, :string, :int], :pointer
+        attach_function :PyEval_EvalCode, [:pointer, :pointer, :pointer], :pointer
+        attach_function :PyErr_SetString, [:pointer, :string], :void
+
+        # Python interpreter startup and shutdown
+        attach_function :Py_IsInitialized, [], :int
+        attach_function :Py_Initialize, [], :void
+        attach_function :Py_Finalize, [], :void
+
+        # Module methods
+        attach_function :PyImport_ImportModule, [:string], :pointer
+
+        # Object Methods
+        attach_function :PyObject_HasAttrString, [:pointer, :string], :int
+        attach_function :PyObject_GetAttrString, [:pointer, :string], :pointer
+        attach_function :PyObject_SetAttrString, [:pointer, :string, :pointer], :int
+        attach_function :PyObject_Dir, [:pointer], :pointer
+
+        attach_function :PyObject_Compare, [:pointer, :pointer], :int
+
+        attach_function :PyObject_Call, [:pointer, :pointer, :pointer], :pointer
+        attach_function :PyObject_CallObject, [:pointer, :pointer], :pointer
+        attach_function :PyCallable_Check, [:pointer], :int
+
+        ### Python To Ruby Conversion
+        # String Methods
+        attach_function :PyString_AsString, [:pointer], :string
+        attach_function :PyString_FromString, [:string], :pointer
+        attach_function :PyString_AsStringAndSize, [:pointer, :pointer, :pointer], :int
+        attach_function :PyString_FromStringAndSize, [:buffer_in, :ssize_t], :pointer
+
+        # List Methods
+        attach_function :PyList_GetItem, [:pointer, :int], :pointer
+        attach_function :PyList_Size, [:pointer], :int
+        attach_function :PyList_New, [:int], :pointer
+        attach_function :PyList_SetItem, [:pointer, :int, :pointer], :void
+
+        # Integer Methods
+        attach_function :PyInt_AsLong, [:pointer], :long
+        attach_function :PyInt_FromLong, [:long], :pointer
+
+        attach_function :PyLong_AsLong, [:pointer], :long
+        attach_function :PyLong_FromLong, [:pointer], :long
+
+        # Float Methods
+        attach_function :PyFloat_AsDouble, [:pointer], :double
+        attach_function :PyFloat_FromDouble, [:double], :pointer
+
+        # Tuple Methods
+        attach_function :PySequence_List, [:pointer], :pointer
+        attach_function :PySequence_Tuple, [:pointer], :pointer
+        attach_function :PyTuple_Pack, [:int, :varargs], :pointer
+
+        # Dict/Hash Methods
+        attach_function :PyDict_Next, [:pointer, :pointer, :pointer, :pointer], :int
+        attach_function :PyDict_New, [], :pointer
+        attach_function :PyDict_SetItem, [:pointer, :pointer, :pointer], :int
+        attach_function :PyDict_Contains, [:pointer, :pointer], :int
+        attach_function :PyDict_GetItem, [:pointer, :pointer], :pointer
+
+        # Error Methods
+        attach_variable :PyExc_Exception, self::DummyStruct.by_ref
+        attach_variable :PyExc_StopIteration, self::DummyStruct.by_ref
+        attach_function :PyErr_SetNone, [:pointer], :void
+        attach_function :PyErr_Fetch, [:pointer, :pointer, :pointer], :void
+        attach_function :PyErr_Occurred, [], :pointer
+        attach_function :PyErr_Clear, [], :void
+
+        # Reference Counting
+        attach_function :Py_IncRef, [:pointer], :void
+        attach_function :Py_DecRef, [:pointer], :void
+
+        # Type Objects
+        # attach_variable :PyBaseObject_Type, self::DummyStruct.by_value # built-in 'object' 
+        # attach_variable :PyBaseString_Type, self::DummyStruct.by_value
+        # attach_variable :PyBool_Type, self::DummyStruct.by_value
+        # attach_variable :PyBuffer_Type, self::DummyStruct.by_value
+        # attach_variable :PyByteArrayIter_Type, self::DummyStruct.by_value
+        # attach_variable :PyByteArray_Type, self::DummyStruct.by_value
+        attach_variable :PyCFunction_Type, self::DummyStruct.by_value
+        # attach_variable :PyCObject_Type, self::DummyStruct.by_value
+        # attach_variable :PyCallIter_Type, self::DummyStruct.by_value
+        # attach_variable :PyCapsule_Type, self::DummyStruct.by_value
+        # attach_variable :PyCell_Type, self::DummyStruct.by_value
+        # attach_variable :PyClassMethod_Type, self::DummyStruct.by_value
+        attach_variable :PyClass_Type, self::DummyStruct.by_value
+        # attach_variable :PyCode_Type, self::DummyStruct.by_value
+        # attach_variable :PyComplex_Type, self::DummyStruct.by_value
+        # attach_variable :PyDictItems_Type, self::DummyStruct.by_value
+        # attach_variable :PyDictIterItem_Type, self::DummyStruct.by_value
+        # attach_variable :PyDictIterKey_Type, self::DummyStruct.by_value
+        # attach_variable :PyDictIterValue_Type, self::DummyStruct.by_value
+        # attach_variable :PyDictKeys_Type, self::DummyStruct.by_value
+        # attach_variable :PyDictProxy_Type, self::DummyStruct.by_value
+        # attach_variable :PyDictValues_Type, self::DummyStruct.by_value
+        attach_variable :PyDict_Type, self::DummyStruct.by_value
+        # attach_variable :PyEllipsis_Type, self::DummyStruct.by_value
+        # attach_variable :PyEnum_Type, self::DummyStruct.by_value
+        # attach_variable :PyFile_Type, self::DummyStruct.by_value
+        attach_variable :PyFloat_Type, self::DummyStruct.by_value
+        # attach_variable :PyFrame_Type, self::DummyStruct.by_value
+        # attach_variable :PyFrozenSet_Type, self::DummyStruct.by_value
+        attach_variable :PyFunction_Type, self::DummyStruct.by_value
+        # attach_variable :PyGen_Type, self::DummyStruct.by_value
+        # attach_variable :PyGetSetDescr_Type, self::DummyStruct.by_value
+        # attach_variable :PyInstance_Type, self::DummyStruct.by_value
+        attach_variable :PyInt_Type, self::DummyStruct.by_value
+        attach_variable :PyList_Type, self::DummyStruct.by_value
+        attach_variable :PyLong_Type, self::DummyStruct.by_value
+        # attach_variable :PyMemberDescr_Type, self::DummyStruct.by_value
+        # attach_variable :PyMemoryView_Type, self::DummyStruct.by_value
+        attach_variable :PyMethod_Type, self::DummyStruct.by_value
+        # attach_variable :PyModule_Type, self::DummyStruct.by_value
+        # attach_variable :PyNullImporter_Type, self::DummyStruct.by_value
+        # attach_variable :PyProperty_Type, self::DummyStruct.by_value
+        # attach_variable :PyRange_Type, self::DummyStruct.by_value
+        # attach_variable :PyReversed_Type, self::DummyStruct.by_value
+        # attach_variable :PySTEntry_Type, self::DummyStruct.by_value
+        # attach_variable :PySeqIter_Type, self::DummyStruct.by_value
+        # attach_variable :PySet_Type, self::DummyStruct.by_value
+        # attach_variable :PySlice_Type, self::DummyStruct.by_value
+        # attach_variable :PyStaticMethod_Type, self::DummyStruct.by_value
+        attach_variable :PyString_Type, self::DummyStruct.by_value
+        # attach_variable :PySuper_Type, self::DummyStruct.by_value # built-in 'super' 
+        # attach_variable :PyTraceBack_Type, self::DummyStruct.by_value
+        attach_variable :PyTuple_Type, self::DummyStruct.by_value
+        attach_variable :PyType_Type, self::DummyStruct.by_value
+        # attach_variable :PyUnicode_Type, self::DummyStruct.by_value
+        # attach_variable :PyWrapperDescr_Type, self::DummyStruct.by_value
+
+        attach_variable :Py_TrueStruct, :_Py_TrueStruct, self::DummyStruct.by_value
+        attach_variable :Py_ZeroStruct, :_Py_ZeroStruct, self::DummyStruct.by_value
+        attach_variable :Py_NoneStruct, :_Py_NoneStruct, self::DummyStruct.by_value
+
+        # This is an implementation of the basic structure of a Python PyObject
+        # struct. The C struct is actually much larger, but since we only access
+        # the first two data members via FFI and always deal with struct
+        # pointers there is no need to mess around with the rest of the object.
+        self.const_set :PyObjectStruct, Class.new(FFI::Struct)
+        self::PyObjectStruct.layout :ob_refcnt, :ssize_t,
+          :ob_type, :pointer
+
+        # This struct is used when defining Python methods.
+        self.const_set :PyMethodDef, Class.new(FFI::Struct)
+        self::PyMethodDef.layout :ml_name, :pointer,
+          :ml_meth, :PyCFunction,
+          :ml_flags, :int,
+          :ml_doc, :pointer
+      end
+
+    end
+  end
+  private :infect!
+end

data/lib/rubypython/pythonerror.rb

@@ -0,0 +1,80 @@
+require 'rubypython/python'
+require 'rubypython/macros'
+
+# Raised when an error occurs in the \Python interpreter.
+class RubyPython::PythonError < RuntimeError
+  # The \Python traceback object associated with this error. This will be
+  # a RubyPython::RubyPyProxy object.
+  attr_reader :traceback
+
+  # Creates the PythonError.
+  # [typeName] The class name of the \Python error.
+  # [msg] The message attached to the \Python error.
+  # [traceback] The traceback, if any, associated with the \Python error.
+  def initialize(typeName, msg, traceback = nil)
+    @type = typeName
+    @traceback = traceback
+    super([typeName, msg].join(': '))
+  end
+
+  # This method should be called when an error has occurred in the \Python
+  # interpreter. This acts as factory function for PythonError objects. The
+  # function fetches calls +#fetch+ to get the error information from the
+  # \Python interpreter and uses this to build a PythonError object. It then
+  # calls +#clear to clear the error flag in the python interpreter. After
+  # the error flag has been cleared, the PythonError object is returned.
+  def self.handle_error
+    rbType, rbValue, rbTraceback = fetch()
+
+    if not rbValue.null?
+      msg = rbValue.getAttr("__str__").callObject RubyPython::PyObject.buildArgTuple
+      msg = msg.rubify
+    else
+      msg = nil
+    end
+
+    if not rbTraceback.null?
+      traceback = RubyPython::RubyPyProxy.new rbTraceback
+    else
+      traceback = nil
+    end
+
+    # Decrease the reference count. This will happen anyway when they go out
+    # of scope but might as well.
+    rbValue.xDecref
+    pyName = rbType.getAttr("__name__")
+
+    rbType.xDecref
+    rbName = pyName.rubify
+    pyName.xDecref
+
+    RubyPython::PythonError.clear
+    RubyPython::PythonError.new(rbName, msg, traceback)
+  end
+
+  # A wrapper to the \Python C API +PyErr_Fetch+ function. Returns an array
+  # with three PyObject instances, representing the Type, the Value, and the
+  # stack trace of the Python error.
+  def self.fetch
+    typePointer = FFI::MemoryPointer.new :pointer
+    valuePointer = FFI::MemoryPointer.new :pointer
+    tracebackPointer = FFI::MemoryPointer.new :pointer
+
+    RubyPython::Python.PyErr_Fetch typePointer, valuePointer, tracebackPointer
+
+    rbType = RubyPython::PyObject.new typePointer.read_pointer
+    rbValue = RubyPython::PyObject.new valuePointer.read_pointer
+    rbTraceback = RubyPython::PyObject.new tracebackPointer.read_pointer
+    [rbType, rbValue, rbTraceback]
+  end
+
+  # Determines whether an error has occurred in the \Python interpreter.
+  def self.error?
+    !RubyPython::Python.PyErr_Occurred.null?
+  end
+
+  # Resets the \Python interpreter error flag
+  def self.clear
+    RubyPython::Python.PyErr_Clear
+  end
+end

data/lib/rubypython/rubypyproxy.rb

@@ -0,0 +1,336 @@
+require 'rubypython/pythonerror'
+require 'rubypython/pyobject'
+require 'rubypython/conversion'
+require 'rubypython/operators'
+require 'rubypython/blankobject'
+
+module RubyPython
+  # In most cases, users will interact with RubyPyProxy objects that hold
+  # references to active objects in the \Python interpreter. RubyPyProxy
+  # delegates method calls to \Python objects, wrapping and returning the
+  # results as RubyPyProxy objects.
+  #
+  # The allocation, deallocation, and reference counting on RubyPyProxy
+  # objects is automatic: RubyPython takes care of it all. When the object
+  # is garbage collected, the instance will automatically decrement its
+  # object reference count.
+  #
+  # [NOTE:]  All RubyPyProxy objects become invalid when the \Python
+  #          interpreter is halted.
+  #
+  # == Calling Methods With Blocks
+  # Any method which is forwarded to a \Python object may be called with a
+  # block. The result of the method will passed as the argument to that
+  # block.
+  #
+  #   RubyPython.run do
+  #     sys = RubyPython.import 'sys'
+  #     sys.version { |v| v.rubify.split(' ') }
+  #   end
+  #   # => [ "2.6.1", … ]
+  #   
+  # == Passing Procs and Methods to \Python Methods
+  # RubyPython supports passing Proc and Method objects to \Python methods.
+  # The Proc or Method object must be passed explicitly. As seen above,
+  # supplying a block to a method will result in the return value of the
+  # method call being passed to the block.
+  #
+  # When a Proc or Method is supplied as a callback, then arguments that it
+  # will be called with will be wrapped \Python objects. It will therefore
+  # typically be necessary to write a wrapper around any Ruby callback that
+  # requires native Ruby objects.
+  #
+  #   # Python Code: sample.py
+  #   def apply_callback(callback, argument):
+  #     return callback(argument)
+  #
+  #   # IRB Session
+  #   >> RubyPython.start
+  #   => true
+  #   >> sys = RubyPython.import 'sys'
+  #   => <module 'sys' (built-in)>
+  #   >> sys.path.append('.')
+  #   => None
+  #   >> sample = RubyPython.import 'sample'
+  #   => <module 'sample' from './sample.pyc'>
+  #   >> callback = Proc.new { |arg| arg * 2 }
+  #   => # <Proc:0x000001018df490@(irb):5>
+  #   >> sample.apply_callback(callback, 21).rubify
+  #   => 42
+  #   >> RubyPython.stop
+  #   => true
+  class RubyPyProxy < BlankObject
+    include Operators
+
+    attr_reader :pObject
+
+    # Creates a \Python proxy for the provided Ruby object.
+    #
+    # Only the following Ruby types can be represented in \Python:
+    # * String
+    # * Array
+    # * Hash
+    # * Fixnum
+    # * Bignum
+    # * Float
+    # * Symbol (as a String)
+    # * Proc
+    # * Method
+    # * +true+ (as True)
+    # * +false+ (as False)
+    # * +nil+ (as None)
+    def initialize(pObject)
+      if pObject.kind_of? PyObject
+        @pObject = pObject
+      else
+        @pObject = PyObject.new pObject
+      end
+    end
+
+    # Handles the job of wrapping up anything returned by a RubyPyProxy
+    # instance. The behavior differs depending on the value of
+    # +RubyPython.legacy_mode+. If legacy mode is inactive, every returned
+    # object is wrapped by an instance of +RubyPyProxy+. If legacy mode is
+    # active, RubyPython first attempts to convert the returned object to a
+    # native Ruby type, and then only wraps the object if this fails.
+    def _wrap(pyobject)
+      if pyobject.class?
+        RubyPyClass.new(pyobject)
+      elsif RubyPython.__send__ :legacy_mode?
+        pyobject.rubify
+      else
+        RubyPyProxy.new(pyobject)
+      end
+    rescue Conversion::UnsupportedConversion => exc
+      RubyPyProxy.new pyobject
+    end
+    private :_wrap
+
+    reveal(:respond_to?)
+
+    # The standard Ruby +#respond_to?+ method has been renamed to allow
+    # RubyPython to query if the proxied \Python object supports the method
+    # desired. Setter methods (e.g., +foo=+) are always supported.
+    alias :is_real_method? :respond_to?
+
+    # RubyPython checks the attribute dictionary of the wrapped object to
+    # check whether it will respond to a method call. This should not return
+    # false positives but it may return false negatives. The built-in Ruby
+    # respond_to? method has been aliased to is_real_method?.
+    def respond_to?(mname)
+      return true if is_real_method?(mname)
+      mname = mname.to_s
+      return true if mname =~ /=$/
+      @pObject.hasAttr(mname)
+    end
+
+    # Delegates method calls to proxied \Python objects.
+    #
+    # == Delegation Rules
+    # 1. If the method ends with a question-mark (e.g., +nil?+), it can only
+    #    be a Ruby method on RubyPyProxy. Attempt to reveal it (RubyPyProxy
+    #    is a BlankObject) and call it.
+    # 2. If the method ends with equals signs (e.g., +value=+) it's a setter
+    #    and we can always set an attribute on a \Python object.
+    # 3. If the method ends with an exclamation point (e.g., +foo!+) we are
+    #    attempting to call a method with keyword arguments.
+    # 4. The Python method or value will be called, if it's callable.
+    # 5. RubyPython will wrap the return value in a RubyPyProxy object
+    #    (unless legacy_mode has been turned on).
+    # 6. If a block has been provided, the wrapped return value will be
+    #    passed into the block.
+    def method_missing(name, *args, &block)
+      name = name.to_s
+
+      if name =~ /\?$/
+        begin
+          RubyPyProxy.reveal(name.to_sym)
+          return self.__send__(name.to_sym, *args, &block)
+        rescue RuntimeError => exc
+          raise NoMethodError.new(name) if exc.message =~ /Don't know how to reveal/
+          raise
+        end
+      end
+
+      kwargs = false
+
+      if name =~ /=$/
+        return @pObject.setAttr(name.chomp('='),
+                                PyObject.convert(*args).first)
+      elsif name =~ /!$/
+        kwargs = true
+        name.chomp! "!"
+      end
+
+      raise NoMethodError.new(name) if !@pObject.hasAttr(name)
+
+      pFunc = @pObject.getAttr(name)
+
+      if pFunc.callable?
+        if args.empty? and pFunc.class?
+          pReturn = pFunc
+        else
+          if kwargs and args.last.is_a?(Hash)
+            pKeywords = PyObject.convert(args.pop).first
+          end
+
+          orig_args = args
+          args = PyObject.convert(*args)
+          pTuple = PyObject.buildArgTuple(*args)
+          pReturn = if pKeywords
+            pFunc.callObjectKeywords(pTuple, pKeywords)
+          else
+            pFunc.callObject(pTuple)
+          end
+
+          # Clean up unused Python vars instead of waiting on Ruby's GC to
+          # do it.
+          pFunc.xDecref
+          pTuple.xDecref
+          pKeywords.xDecref if pKeywords
+          orig_args.each_with_index do |arg, i|
+            # Only decref objects that were created in PyObject.convert.
+            if !arg.kind_of?(RubyPython::PyObject) and !arg.kind_of?(RubyPython::RubyPyProxy)
+              args[i].xDecref
+            end
+          end
+
+          raise PythonError.handle_error if PythonError.error?
+        end
+      else
+        pReturn = pFunc
+      end
+
+      result = _wrap(pReturn)
+
+      if block
+        block.call(result)
+      else
+        result
+      end
+    end
+
+    # RubyPython will attempt to translate the wrapped object into a native
+    # Ruby object. This will only succeed for simple built-in type.
+    def rubify
+      @pObject.rubify
+    end
+
+    # Returns the String representation of the wrapped object via a call to
+    # the object's <tt>__repr__</tt> method, or the +repr+ method in PyMain.
+    def inspect
+      self.__repr__.rubify
+    rescue PythonError, NoMethodError
+      RubyPython::PyMain.repr(self).rubify
+    end
+
+    # Returns the string representation of the wrapped object via a call to
+    # the object's <tt>__str__</tt> method or the +str+ method in PyMain.
+    def to_s
+      self.__str__.rubify
+    rescue PythonError, NoMethodError
+      RubyPython::PyMain.str(self).rubify
+    end
+
+    # Converts the wrapped \Python object to a Ruby Array. Note that this
+    # only converts one level, so a nested array will remain a proxy object.
+    # Only wrapped objects which have an <tt>__iter__</tt> method may be
+    # converted using +to_a+.
+    #
+    # Note that for \Python Dict objects, this method returns what you would
+    # get in \Python, not in Ruby: +a_dict.to_a+ returns an array of the
+    # dictionary's keys.
+    #
+    # === List #to_a Returns an Array
+    #   >> RubyPython.start
+    #   => true
+    #   >> list = RubyPython::RubyPyProxy.new([1, 'a', 2, 'b'])
+    #   => [1, 'a', 2, 'b']
+    #   >> list.kind_of? RubyPython::RubyPyProxy
+    #   => true
+    #   >> list.to_a
+    #   => [1, 'a', 2, 'b']
+    #   >> RubyPython.stop
+    #   => true
+    #
+    # === Dict #to_a Returns An Array of Keys
+    #   >> RubyPython.start
+    #   => true
+    #   >> dict = RubyPython::RubyPyProxy.new({1 => '2', :three => [4,5]})
+    #   => {1: '2', 'three': [4, 5]}
+    #   >> dict.kind_of? RubyPython::RubyPyProxy
+    #   => true
+    #   >> dict.to_a
+    #   => [1, 'three']
+    #   >> RubyPython.stop
+    #   => true
+    #
+    # === Non-Array Values Do Not Convert
+    #   >> RubyPython.start
+    #   => true
+    #   >> item = RubyPython::RubyPyProxy.new(42)
+    #   => 42
+    #   >> item.to_a
+    #   NoMethodError: __iter__
+    def to_a
+      iter = self.__iter__
+      ary = []
+      loop do
+        ary << iter.next()
+      end
+    rescue PythonError => exc
+      raise if exc.message !~ /StopIteration/
+      ary
+    end
+
+    # Returns the methods on the \Python object by calling the +dir+
+    # built-in.
+    def methods
+      pObject.dir.map { |x| x.to_sym }
+    end
+
+    # Creates a PyEnumerable for this object. The object must have the
+    # <tt>__iter__</tt> method.
+    def to_enum
+      PyEnumerable.new(@pObject)
+    end
+  end
+
+  # A class to wrap \Python modules. It behaves exactly the same as
+  # RubyPyProxy. It is just here for Bookkeeping and aesthetics.
+  class RubyPyModule < RubyPyProxy; end
+
+  # A class to wrap \Python classes.
+  class RubyPyClass < RubyPyProxy
+    # Create an instance of the wrapped class. This is a workaround for the
+    # fact that \Python classes are meant to be callable.
+    def new(*args)
+      args = PyObject.convert(*args)
+      pTuple = PyObject.buildArgTuple(*args)
+      pReturn = @pObject.callObject(pTuple)
+      raise PythonError.handle_error if PythonError.error?
+      RubyPyInstance.new pReturn
+    end
+  end
+
+  # An object representing an instance of a \Python class. It behaves
+  # exactly the same as RubyPyProxy. It is just here for Bookkeeping and
+  # aesthetics.
+  class RubyPyInstance < RubyPyProxy; end
+
+  # An object representing a Python enumerable object.
+  class PyEnumerable < RubyPyProxy
+    include Enumerable
+
+    def each
+      iter = self.__iter__
+      loop do
+        begin
+          yield iter.next
+        rescue RubyPython::PythonError => exc
+          return if exc.message =~ /StopIteration/
+        end
+      end
+    end
+  end
+end