lokeshh_rubypython 0.7

data/lib/rubypython/rubypyproxy.rb

@@ -0,0 +1,328 @@
+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. Every returned # object is wrapped by an instance of +RubyPyProxy+
+    def _wrap(pyobject)
+      if pyobject.class?
+        RubyPyClass.new(pyobject)
+      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
+    # 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.new(args.pop))
+      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.new args.pop
+          end
+          pReturn = _method_call(pFunc, args, pKeywords)
+          pFunc.xDecref
+        end
+      else
+        pReturn = pFunc
+      end
+
+      result = _wrap(pReturn)
+
+      if block
+        block.call(result)
+      else
+        result
+      end
+    end
+
+    #Handles the of calling a wrapped callable Python object at a higher level
+    #than +PyObject#callObject+. For internal use only.
+    def _method_call(pFunc, args, pKeywords)
+      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.
+      pTuple.xDecref
+      pKeywords.xDecref if pKeywords
+      raise PythonError.handle_error if PythonError.error?
+      pReturn
+    end
+    private :_method_call
+
+    # RubyPython will attempt to translate the wrapped object into a native
+    # Ruby object. This will only succeed for simple built-in type.
+    def rubify
+      converted = @pObject.rubify
+      if converted.kind_of? ::FFI::Pointer
+        converted = self.class.new converted
+      end
+      converted
+    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)
+      pReturn =  _method_call(@pObject, args, nil)
+      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

data/lib/rubypython/tuple.rb

@@ -0,0 +1,10 @@
+module RubyPython
+  # A subclass of ::Array that will convert to a Python Tuple automatically.
+  class Tuple < ::Array
+    def self.tuple(array)
+      value = self.new
+      value.replace(array.dup)
+      value
+    end
+  end
+end

data/lib/rubypython/type.rb

@@ -0,0 +1,20 @@
+module RubyPython
+  # Creates a Ruby class that inherits from a proxied Python object.
+  def self.Type(name)
+    mod, match, klass = name.rpartition(".")
+    pymod = RubyPython.import(mod)
+    pyclass = pymod.pObject.getAttr(klass)
+    rclass = Class.new(RubyPyProxy) do
+      define_method(:initialize) do |*args|
+        args = PyObject.convert(*args)
+        pTuple = PyObject.buildArgTuple(*args)
+        pReturn = pyclass.callObject(pTuple)
+        if PythonError.error?
+          raise PythonError.handle_error
+        end
+        @pObject = pReturn
+      end
+    end
+    return rclass
+  end
+end

data/lib/rubypython.rb

@@ -0,0 +1,229 @@
+# 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.4'
+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
+    ## 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 = {})
+      RubyPython::Python.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
+
+        return false if RubyPython::Python.Py_IsInitialized != 0
+        RubyPython::Python.Py_Initialize
+        notify :start
+        true
+      end
+    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
+      RubyPython::Python.synchronize do
+        if defined? Python.Py_IsInitialized and Python.Py_IsInitialized != 0
+          Python.Py_Finalize
+          notify :stop
+          true
+        else
+          false
+        end
+      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/spec/basic_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+
+describe "RubyPython" do
+  it "can import and use a native extension like cPickle" do
+    cPickle = RubyPython.import("cPickle")
+    string = cPickle.dumps("Testing RubyPython.")
+    string.should_not be_a_kind_of String
+    string.rubify.should be_a_kind_of String
+    string.rubify.should ~ /S'Testing RubyPython.'\n/
+  end
+
+  it "can import and use a pure Python extension like pickle" do
+    pickle = RubyPython.import("pickle")
+    string = pickle.dumps("Testing RubyPython.")
+    string.should_not be_a_kind_of String
+    string.rubify.should be_a_kind_of String
+    string.rubify.should ~ /S'Testing RubyPython.'\n/
+  end
+
+  it "can use iterators from Python" do
+    items = []
+    @basics.iterate_list.to_enum.each { |item| items << item }
+    items.should == [ 1, 2, 3 ]
+  end
+
+  it "can use Ruby procs as callbacks to Python code" do
+    @basics.simple_callback(lambda { |v| v * v }, 4).should == 16
+  end
+
+  it "can use Ruby methods as callbacks to Python code" do
+    def triple(v)
+      v * 3
+    end
+    @basics.simple_callback(method(:triple), 4).should == 12
+  end
+
+  it "can feed a Python generator in Ruby 1.9", :ruby_version => '1.9' do
+    output = @basics.simple_generator(RubyPython.generator do
+      (1..10).each { |i| RubyPython.yield i }
+    end)
+    output.should == [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
+  end
+
+  it "can use named parameters to functions" do
+    @basics.named_args(2, 1).should == [ 2, 1 ]
+    @basics.named_args!(:arg2 => 2, :arg1 => 1).should == [ 1, 2 ]
+  end
+end

data/spec/callback_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include TestConstants
+
+describe 'Callbacks' do
+  {
+    'procs' => AProc,
+    'methods' => AMethod,
+  }.each do |rb_type, rb_object|
+    it "accepts #{rb_type} as functions" do
+      [
+        [2, 2],
+        ["a", "Word"],
+        [ [1, 2], [3, 4] ]
+      ].each do |args|
+        @objects.apply_callback(rb_object, args).should == rb_object.call(*args)
+      end
+    end
+  end
+
+  [
+    ["an int", AnInt],
+    ["a float", AFloat],
+    ["a string", AString],
+    ["a string with nulls", AStringWithNULLs],
+    ["an array", AnArray],
+    ["an array", AnArray],
+    ["a hash", AConvertedHash],
+    ["true", true],
+    ["false", false],
+    ["nil", nil]
+  ].each do |rb_type, rb_value|
+    it "is able to return #{rb_type}" do
+      callback = Proc.new do 
+        rb_value
+      end
+
+      @objects.apply_callback(callback, []).should == rb_value
+    end
+  end
+
+  it "is able to be stored by python variables" do
+    mockObject = @objects.RubyPythonMockObject.new
+    mockObject.callback = AProc
+  end
+
+  it "is callable as a python instance variable" do
+    mockObject = @objects.RubyPythonMockObject.new
+    mockObject.callback = AProc
+    mockObject.callback(2, 2).rubify.should == 4
+  end
+
+end