lokeshh_rubypython 0.7

data/lib/rubypython/pyobject.rb

@@ -0,0 +1,189 @@
+require 'rubypython/python'
+require 'rubypython/macros'
+require 'rubypython/conversion'
+require 'ffi'
+
+# This object is an opaque wrapper around the C Py…Object types used by the
+# \Python C API.
+#
+# This class is *only* for RubyPython internal use.
+class RubyPython::PyObject # :nodoc: all
+  # This class wraps C <tt>Py…Object</tt>s so that the RubyPython::Python
+  # reference count is automatically decreased when the Ruby object
+  # referencing them goes out of scope.
+  class AutoPyPointer < ::FFI::AutoPointer # :nodoc:
+    class << self
+      # Keeps track of which objects are associated with the currently
+      # running RubyPython::Python interpreter, so that RubyPython knows not
+      # to try to decrease the reference counts of the others when garbage
+      # collecting.
+      attr_accessor :current_pointers
+
+      # When used along with the FFI Library method is executed whenever a
+      # pointer is garbage collected so that cleanup can be done. In our
+      # case we decrease the reference count of the held pointer as long as
+      # the object is still good. There is really no reason the end-user
+      # would need to the use this method directly.
+      def release(pointer)
+        obj_id = pointer.object_id
+        deleted = @current_pointers.delete(obj_id)
+        if pointer.null?
+          puts "Warning: Trying to DecRef NULL pointer" if RubyPython::Python.Py_IsInitialized != 0
+          return
+        end
+        if deleted and (RubyPython::Python.Py_IsInitialized != 0)
+          RubyPython::Python.Py_DecRef pointer
+        end
+      end
+
+      # Called by RubyPython when the interpreter is started or stopped so
+      # that the necessary preparation or cleanup can be done. For internal
+      # use only.
+      def python_interpreter_update(status)
+        case status
+        when :stop
+          current_pointers.clear
+        end
+      end
+      private :python_interpreter_update
+    end
+
+    self.current_pointers = {}
+  end
+
+  # The AutoPyPointer object which represents the RubyPython::Python
+  # Py…Object.
+  attr_reader :pointer
+
+  # [rObject] FFI Pointer objects passed into the constructor are wrapped in
+  # an AutoPyPointer and assigned to the +#pointer+ attribute. Other objects
+  # are converted, if possible, from their Ruby types to their \Python types
+  # and wrapped in an AutoPyPointer. The conversion is done with
+  # +RubyPython::Conversion.rtopObject+.
+  def initialize(rObject)
+    if rObject.kind_of? ::FFI::AutoPointer
+      new_pointer = ::FFI::Pointer.new rObject
+      @pointer = AutoPyPointer.new new_pointer
+      xIncref
+    elsif rObject.kind_of? ::FFI::Pointer
+      @pointer = AutoPyPointer.new rObject
+    else
+      @pointer = AutoPyPointer.new RubyPython::Conversion.rtopObject(rObject)
+    end
+    AutoPyPointer.current_pointers[@pointer.object_id] = true
+  end
+
+  # Attempts to convert the wrapped object to a native ruby type. Returns
+  # either the Ruby object or the unmodified \Python object.
+  def rubify
+    RubyPython::Conversion.ptorObject @pointer
+  end
+
+  # Tests whether the wrapped \Python object has a given attribute. Returns
+  # +true+ if the attribute exists.
+  # [attrName] The name of the attribute to look up.
+  def hasAttr(attrName)
+    RubyPython::Python.PyObject_HasAttrString(@pointer, attrName) == 1
+  end
+
+  # Retrieves an object from the wrapped \Python object.
+  # [attrName] The name of the attribute to fetch.
+  def getAttr(attrName)
+    pyAttr = RubyPython::Python.PyObject_GetAttrString(@pointer, attrName)
+    self.class.new pyAttr
+  end
+
+  # Sets an attribute of the wrapped \Python object. Returns +true+ if the
+  # attribute was successfully set.
+  # [attrName] The name of the attribute to set.
+  # [rbPyAttr] A PyObject wrapper around the value that we wish to set the
+  # attribute to.
+  def setAttr(attrName, rbPyAttr)
+    #SetAttrString should incref whatever gets passed to it.
+    RubyPython::Python.PyObject_SetAttrString(@pointer, attrName, rbPyAttr.pointer) != -1
+  end
+
+  # Calls the wrapped \Python object with the supplied arguments and keyword
+  # arguments. Returns a PyObject wrapper around the returned object, which
+  # may be +NULL+.
+  # [rbPyArgs]      A PyObject wrapping a Tuple of the supplied arguments.
+  # [rbPyKeywords]  A PyObject wrapping a Dict of keyword arguments.
+  def callObjectKeywords(rbPyArgs, rbPyKeywords)
+    pyReturn = RubyPython::Python.PyObject_Call(@pointer, rbPyArgs.pointer, rbPyKeywords.pointer)
+    self.class.new pyReturn
+  end
+
+  # Calls the wrapped \Python object with the supplied arguments. Returns a
+  # PyObject wrapper around the returned object, which may be +NULL+.
+  # [rbPyArgs]  A PyObject wrapping a Tuple of the supplied arguments.
+  def callObject(rbPyArgs)
+    pyReturn = RubyPython::Python.PyObject_CallObject(@pointer, rbPyArgs.pointer)
+    self.class.new pyReturn
+  end
+
+  # Decrease the reference count of the wrapped object.
+  def xDecref
+    AutoPyPointer.release(@pointer)
+    @pointer = nil
+  end
+
+  # Increase the reference count of the wrapped object
+  def xIncref
+    RubyPython::Python.Py_IncRef @pointer
+    nil
+  end
+
+  # Tests whether the wrapped object is +NULL+.
+  def null?
+    @pointer.null?
+  end
+
+  # Performs a compare on two Python objects. Returns a value similar to
+  # that of the spaceship operator (<=>).
+  def cmp(other)
+    RubyPython::Python.PyObject_Compare @pointer, other.pointer
+  end
+
+  # Tests whether the wrapped object is a function or a method. This is not
+  # the same as #callable? as many other \Python objects are callable.
+  def function_or_method?
+    check = RubyPython::Macros.PyObject_TypeCheck(@pointer, [
+                                                  RubyPython::Python.PyFunction_Type.to_ptr,
+                                                  RubyPython::Python.PyCFunction_Type.to_ptr,
+                                                  RubyPython::Python.PyMethod_Type.to_ptr
+    ])
+    check != 0
+  end
+
+  # Is the wrapped object callable?
+  def callable?
+    RubyPython::Python.PyCallable_Check(@pointer) != 0
+  end
+
+  # Returns the 'directory' of the RubyPython::Python object; similar to #methods in
+  # Ruby.
+  def dir
+    return self.class.new(RubyPython::Python.PyObject_Dir(@pointer)).rubify.map do |x|
+      x.to_sym
+    end
+  end
+
+  # Tests whether the wrapped object is a RubyPython::Python class (both new
+  # and old style).
+  def class?
+    check = RubyPython::Macros.PyObject_TypeCheck(@pointer, [
+                                                  RubyPython::Python.PyClass_Type.to_ptr,
+                                                  RubyPython::Python.PyType_Type.to_ptr
+    ])
+    check != 0
+  end
+
+
+  # Takes an array of objects, converting them to \Python objects if necessary,
+  # and wraps them in a Tuple such that they may be passed to #callObject.
+  # [args] An array; the arguments to be inserted into the
+  # Tuple.
+  def self.buildArgTuple(*args)
+    self.new RubyPython::Conversion.rtopArrayToTuple(args)
+  end
+end

data/lib/rubypython/python.rb

@@ -0,0 +1,199 @@
+require 'ffi'
+require 'thread'
+require 'rubypython/interpreter'
+
+module RubyPython
+  # This module will hold the loaded RubyPython interpreter.
+  module Python #:nodoc: all
+    @lock = Mutex.new
+
+    def self.synchronize(&block)
+      @lock.synchronize(&block)
+    end
+  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)
+    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_FromLongLong, [:long_long], :pointer
+
+      # Float Methods
+      attach_function :PyFloat_AsDouble, [:pointer], :double
+      attach_function :PyFloat_FromDouble, [:double], :pointer
+
+      # Tuple Methods
+      attach_function :PySequence_List, [:pointer], :pointer
+      attach_function :PyList_AsTuple, [: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
+
+  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 if not rbValue.null?
+    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