lokeshh_rubypython 0.7

data/lib/rubypython/interpreter.rb

@@ -0,0 +1,262 @@
+# -*- ruby encoding: utf-8 -*-
+
+class RubyPython::InvalidInterpreter < Exception
+end
+
+##
+# An instance of this class represents information about a particular
+# \Python interpreter.
+#
+# This class represents the current Python interpreter.
+# A class that represents a \Python executable.
+#
+# End users may get the instance that represents the current running \Python
+# interpreter (from +RubyPython.python+), but should not directly
+# instantiate this class.
+class RubyPython::Interpreter
+
+  ##
+  # Compare the current Interpreter to the provided Interpreter or
+  # configuration hash. A configuration hash will be converted to an
+  # Interpreter object before being compared.
+  # :python_exe basename is used. If comparing against another Interpreter
+  # object, the Interpreter basename and version are used.
+  def ==(other)
+    other = self.class.new(other) if other.kind_of? Hash
+    return false unless other.kind_of? self.class
+    (self.version == other.version) && (self.version_name == other.version_name)
+  end
+
+  ##
+  # Create a new instance of an Interpreter instance describing a particular
+  # \Python executable and shared library.
+  #
+  # Expects a hash that matches the configuration options provided to
+  # RubyPython.start; currently only one value is recognized in that hash:
+  #
+  # * <tt>:python_exe</tt>: Specifies the name of the python executable to
+  #   run.
+  def initialize(options = {})
+    @python_exe = options[:python_exe]
+    # Windows: 'C:\\Python27\python.exe'
+    # Mac OS X: '/usr/bin/
+
+    # The default interpreter might be python3 on some systems
+    rc, majorversion = runpy "import sys; print(sys.version_info[0])"
+    if majorversion == "3"
+      warn "The python interpreter is python 3, switching to python2"
+      @python_exe = "python2"
+    end
+
+    rc, @python     = runpy "import sys; print sys.executable"
+    if rc.exitstatus.nonzero?
+      raise RubyPython::InvalidInterpreter, "An invalid interpreter was specified."
+    end
+    rc, @version    = runpy "import sys; print '%d.%d' % sys.version_info[:2]"
+    rc, @sys_prefix = runpy "import sys; print sys.prefix"
+
+    if ::FFI::Platform.windows?
+      flat_version  = @version.tr('.', '')
+      basename      = File.basename(@python, '.exe')
+
+      if basename =~ /(?:#{@version}|#{flat_version})$/
+        @version_name = basename
+      else
+        @version_name = "#{basename}#{flat_version}"
+      end
+    else
+      basename = File.basename(@python)
+      if basename =~ /#{@version}/
+        @version_name = basename
+      elsif basename.end_with?("2")
+        @version_name = "#{basename[0..-2]}#{@version}"
+      else
+        @version_name = "#{basename}#{@version}"
+      end
+    end
+
+    @library = find_python_lib
+  end
+
+  def find_python_lib
+    # By default, the library name will be something like
+    # libpython2.6.so, but that won't always work.
+    @libbase = "#{::FFI::Platform::LIBPREFIX}#{@version_name}"
+    @libext = ::FFI::Platform::LIBSUFFIX
+    @libname = "#{@libbase}.#{@libext}"
+
+    # We may need to look in multiple locations for Python, so let's
+    # build this as an array.
+    @locations = [ File.join(@sys_prefix, "lib", @libname) ]
+
+    if ::FFI::Platform.mac?
+      # On the Mac, let's add a special case that has even a different
+      # @libname. This may not be fully useful on future versions of OS
+      # X, but it should work on 10.5 and 10.6. Even if it doesn't, the
+      # next step will (/usr/lib/libpython<version>.dylib is a symlink
+      # to the correct location).
+      @locations << File.join(@sys_prefix, "Python")
+      # Let's also look in the location that was originally set in this
+      # library:
+      File.join(@sys_prefix, "lib", "#{@realname}", "config", @libname)
+    end
+
+    if ::FFI::Platform.unix?
+      # On Unixes, let's look in some standard alternative places, too.
+      # Just in case. Some Unixes don't include a .so symlink when they
+      # should, so let's look for the base cases of .so.1 and .so.1.0, too.
+      [ @libname, "#{@libname}.1", "#{@libname}.1.0" ].each do |name|
+        if ::FFI::Platform::ARCH != 'i386'
+          @locations << File.join("/opt/local/lib64", name)
+          @locations << File.join("/opt/lib64", name)
+          @locations << File.join("/usr/local/lib64", name)
+          @locations << File.join("/usr/lib64", name)
+          @locations << File.join("/usr/lib/x86_64-linux-gnu", name)
+        end
+        @locations << File.join("/opt/local/lib", name)
+        @locations << File.join("/opt/lib", name)
+        @locations << File.join("/usr/local/lib", name)
+        @locations << File.join("/usr/lib", name)
+      end
+    end
+
+    if ::FFI::Platform.windows?
+      # On Windows, the appropriate DLL is usually be found in
+      # %SYSTEMROOT%\system or %SYSTEMROOT%\system32; as a fallback we'll
+      # use C:\Windows\system{,32} as well as the install directory and the
+      # install directory + libs.
+      system_root = File.expand_path(ENV['SYSTEMROOT']).gsub(/\\/, '/')
+      @locations << File.join(system_root, 'system', @libname)
+      @locations << File.join(system_root, 'system32', @libname)
+      @locations << File.join("C:/WINDOWS", "System", @libname)
+      @locations << File.join("C:/WINDOWS", "System32", @libname)
+      @locations << File.join(sys_prefix, @libname)
+      @locations << File.join(sys_prefix, 'libs', @libname)
+      @locations << File.join(system_root, "SysWOW64", @libname)
+      @locations << File.join("C:/WINDOWS", "SysWOW64", @libname)
+    end
+
+    # Let's add alternative extensions; again, just in case.
+    @locations.dup.each do |location|
+      path = File.dirname(location)
+      base = File.basename(location, ".#{@libext}")
+      @locations << File.join(path, "#{base}.so")    # Standard Unix
+      @locations << File.join(path, "#{base}.dylib") # Mac OS X
+      @locations << File.join(path, "#{base}.dll")   # Windows
+    end
+
+    # Remove redundant locations
+    @locations.uniq!
+
+    library = nil
+
+    @locations.each do |location|
+      if File.exists? location
+        library = location
+        break
+      end
+    end
+
+    library
+  end
+  private :find_python_lib
+
+  def valid?
+    if @python.nil? or @python.empty?
+      false
+    elsif @library.nil? or @library.empty?
+      false
+    else
+      true
+    end
+  end
+
+  ##
+  # The name of the \Python executable that is used. This is the value of
+  # 'sys.executable' for the \Python interpreter provided in
+  # <tt>:python_exe</tt> or 'python' if it is not provided.
+  #
+  # On Mac OS X Lion (10.7), this value is '/usr/bin/python' for 'python'.
+  attr_reader :python
+  ##
+  # The version of the \Python interpreter. This is a decimalized version of
+  # 'sys.version_info[:2]' (such that \Python 2.7.1 is reported as '2.7').
+  attr_reader :version
+  ##
+  # The system prefix for the \Python interpreter. This is the value of
+  # 'sys.prefix'.
+  attr_reader :sys_prefix
+  ##
+  # The basename of the \Python interpreter with a version number. This is
+  # mostly an intermediate value used to find the shared \Python library,
+  # but /usr/bin/python is often a link to /usr/bin/python2.7 so it may be
+  # of value. Note that this does *not* include the full path to the
+  # interpreter.
+  attr_reader :version_name
+
+  # The \Python library.
+  attr_reader :library
+
+  # Run a Python command-line command.
+  def runpy(command)
+    i = @python || @python_exe || 'python'
+    if ::FFI::Platform.windows?
+      o = %x(#{i} -c "#{command}" 2> NUL:)
+    else
+      o = %x(#{i} -c "#{command}" 2> /dev/null)
+    end
+
+    [ $?, o.chomp ]
+  end
+  private :runpy
+
+  def inspect(debug = false)
+    if debug
+      debug_s
+    elsif @python
+      "#<#{self.class}: #{python} v#{version} #{sys_prefix} #{version_name}>"
+    else
+      "#<#{self.class}: invalid interpreter>"
+    end
+  end
+
+  def debug_s(format = nil)
+    system = ""
+    system << "windows " if ::FFI::Platform.windows?
+    system << "mac " if ::FFI::Platform.mac?
+    system << "unix " if ::FFI::Platform.unix?
+    system << "unknown " if system.empty?
+
+    case format
+    when :report
+      s = <<-EOS
+python_exe:   #{@python_exe}
+python:       #{@python}
+version:      #{@version}
+sys_prefix:   #{@sys_prefix}
+version_name: #{@version_name}
+platform:     #{system.chomp}
+library:      #{@library.inspect}
+  libbase:    #{@libbase}
+  libext:     #{@libext}
+  libname:    #{@libname}
+  locations:  #{@locations.inspect}
+      EOS
+    else
+      s = "#<#{self.class}: "
+      s << "python_exe=#{@python_exe.inspect} "
+      s << "python=#{@python.inspect} "
+      s << "version=#{@version.inspect} "
+      s << "sys_prefix=#{@sys_prefix.inspect} "
+      s << "version_name=#{@version_name.inspect} "
+      s << system
+      s << "library=#{@library.inspect} "
+      s << "libbase=#{@libbase.inspect} "
+      s << "libext=#{@libext.inspect} "
+      s << "libname=#{@libname.inspect} "
+      s << "locations=#{@locations.inspect}"
+    end
+
+    s
+  end
+end

data/lib/rubypython/macros.rb

@@ -0,0 +1,56 @@
+require 'ffi'
+require 'rubypython/python'
+
+# Contains Python C API macros reimplemented in Ruby. For internal use only.
+module RubyPython::Macros #:nodoc:
+  # Returns the reference count for the provided pointer.
+  def self.Py_REFCNT(pObjPointer)
+    pStruct = RubyPython::Python::PyObjectStruct.new pObjPointer
+    pStruct[:ob_refcnt]
+  end
+
+  # Returns the object type for the provided pointer.
+  def self.Py_TYPE(pObjPointer)
+    pStruct = RubyPython::Python::PyObjectStruct.new pObjPointer
+    pStruct[:ob_type]
+  end
+
+  # This has been modified from the C API macro to allow for multiple
+  # pointer objects to be passed. It simplifies a number of checks.
+  def self.PyObject_TypeCheck(pObject, pTypePointer)
+    type = self.Py_TYPE(pObject)
+
+    [ pTypePointer ].flatten.each do |pointer|
+      return 1 if type == pointer
+    end
+
+    return 0
+  end
+
+  def self.Py_True
+    RubyPython::Python.Py_TrueStruct.to_ptr
+  end
+
+  def self.Py_False
+    RubyPython::Python.Py_ZeroStruct.to_ptr
+  end
+
+  def self.Py_None
+    RubyPython::Python.Py_NoneStruct.to_ptr
+  end
+
+  def self.Py_RETURN_FALSE
+    RubyPython::Python.Py_IncRef(self.Py_False)
+    self.Py_False
+  end
+
+  def self.Py_RETURN_TRUE
+    RubyPython::Python.Py_IncRef(self.Py_True)
+    self.Py_True
+  end
+
+  def self.Py_RETURN_NONE
+    RubyPython::Python.Py_IncRef(self.Py_None)
+    self.Py_None
+  end
+end

data/lib/rubypython/operators.rb

@@ -0,0 +1,120 @@
+# A mixin module to provide method delegation to a proxy class. This is done
+# either by delegating to methods defined on the wrapped object or by using
+# the \Python _operator_ module. A large number of the methods are
+# dynamically generated and so their documentation is not provided here. In
+# general all operators that can be overloaded are delegated.
+module RubyPython::Operators
+  # Provides access to the \Python _operator_ module.
+  def self.operator_
+    @@operator ||= RubyPython.import('operator')
+  end
+
+  # Creates a method to delegate a binary operation.
+  # [rname] The name of the Ruby method for this operation. Can be either a
+  # Symbol or a String.
+  # [pname] The name of the \Python magic method to which this method should
+  # be delegated.
+  def self.bin_op(rname, pname)
+    define_method rname.to_sym do |other|
+      self.__send__(pname, other)
+    end
+  end
+
+  # Creates a method to delegate a relational operator. The result of the
+  # delegated method will always be converted to a Ruby type so that simple
+  # boolean testing may occur. These methods are implemented with calls the
+  # _operator_ module.
+  #
+  # [rname] The name of the Ruby method for this operation. Can be a Symbol
+  # or a String.
+  # [pname] The name of the \Python magic method to which this method should
+  # be delegated.
+  def self.rel_op(rname, pname)
+    define_method rname.to_sym do |other|
+      RubyPython::Operators.operator_.__send__(pname, self, other).rubify
+    end
+  end
+
+  # Creates a method to delegate a relational operator. 
+  # These methods are implemented with calls the _operator_ module.
+  # [rname] The name of the Ruby method for this operation. Can be a Symbol
+  # or a String.
+  # [pname] The name of the \Python magic method to which this method should
+  # be delegated.
+  def self.unary_op(rname, pname)
+    define_method rname.to_sym do
+      RubyPython::Operators.operator_.__send__(pname, self)
+    end
+  end
+
+  [
+    [:+, '__add__'],
+    [:-, '__sub__'],
+    [:*, '__mul__'],
+    [:/, '__div__'],
+    [:&, '__and__'],
+    [:^, '__xor__'],
+    [:%, '__mod__'],
+    [:**, '__pow__'],
+    [:>>, '__rshift__'],
+    [:<<, '__lshift__'],
+    [:|, '__or__']
+  ].each do |args|
+    bin_op *args
+  end
+
+  [
+    [:~, :__invert__],
+    [:+@, :__pos__],
+    [:-@, :__neg__]
+  ].each do |args|
+    unary_op *args
+  end
+
+  [
+    [:==, 'eq'],
+    [:<, 'lt'],
+    [:<=, 'le'],
+    [:>, 'gt'],
+    [:>=, 'ge'],
+    [:equal?, 'is_']
+  ].each do |args|
+    rel_op *args
+  end
+
+  # Delegates object indexed access to the wrapped \Python object.
+  def [](index)
+    self.__getitem__ index
+  end
+
+  # Delegates setting of various indices to the wrapped \Python object.
+  def []=(index, value)
+    self.__setitem__ index, value
+  end
+
+  # Delegates membership testing to \Python.
+  def include?(item)
+    self.__contains__(item).rubify
+  end
+
+  # Delegates Comparison to \Python.
+  def <=>(other)
+    RubyPython::PyMain.cmp(self, other)
+  end
+
+  class << self
+    # 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
+        @@operator = nil
+      end
+    end
+    private :python_interpreter_update
+  end
+
+  # Aliases eql? to == for Python objects.
+  alias_method :eql?, :==
+end

data/lib/rubypython/pygenerator.rb

@@ -0,0 +1,61 @@
+require "rubypython/python"
+require "rubypython/conversion"
+require 'rubypython/macros'
+require 'rubypython/conversion'
+require 'rubypython/pyobject'
+require "rubypython/pymainclass"
+require "rubypython/rubypyproxy"
+
+if defined? Fiber
+  module RubyPython
+    class << self
+      # Creates a \Python generator object called +rubypython_generator+
+      # that accepts a callback and yields to it.
+      #
+      # *Note*: This method only exists in the RubyPython if the Fiber
+      # exists.
+      def generator_type
+        @generator_type ||= lambda do
+          code = <<-EOM
+def rubypython_generator(callback):
+  while True:
+    yield callback()
+          EOM
+
+          globals = PyObject.new({ "__builtins__" => PyMain.builtin.pObject, })
+          empty_hash = PyObject.new({})
+          ptr = Python.PyRun_String(code, Python::PY_FILE_INPUT, globals.pointer, empty_hash.pointer)
+          ptr = Python.PyRun_String("rubypython_generator", Python::PY_EVAL_INPUT, globals.pointer, empty_hash.pointer)
+          raise PythonError.handle_error if PythonError.error?
+          RubyPyProxy.new(PyObject.new(ptr))
+        end.call
+      end
+
+      # Creates a Ruby lambda that acts like a \Python generator. Uses
+      # +RubyPython.generator_type+ and Fiber to work the generator as a
+      # coroutine.
+      #
+      # *Note*: This method only exists in the RubyPython if the Fiber
+      # exists.
+      def generator
+        return lambda do |*args|
+          fib = Fiber.new do
+            yield *args
+            Python.PyErr_SetNone(Python.PyExc_StopIteration)
+            ::FFI::Pointer::NULL
+          end
+          generator_type.__call__(lambda { fib.resume })
+        end
+      end
+
+      # Performs a +Fiber.yield+ with the provided arguments, continuing the
+      # coroutine execution of the generator.
+      #
+      # *Note*: This method only exists in the RubyPython if the Fiber
+      # exists.
+      def yield(*args)
+        Fiber.yield(*args)
+      end
+    end
+  end
+end

data/lib/rubypython/pymainclass.rb

@@ -0,0 +1,80 @@
+require 'rubypython/blankobject'
+require 'singleton'
+
+module RubyPython
+  # A singleton object providing access to the \Python <tt>__main__</tt> and
+  # <tt>__builtin__</tt> modules. This can be conveniently accessed through
+  # +PyMain+. The <tt>__main__</tt> namespace is searched before the
+  # <tt>__builtin__</tt> namespace. As such, naming clashes will be resolved
+  # in that order.
+  #
+  #   RubyPython::PyMain.dir("dir") # => ['__add__', '__class__', … ]
+  #
+  # === Block Syntax
+  # PyMainClass provides experimental block support for called methods. A
+  # block may be passed to a method call and the object returned by the
+  # function call will be passed as an argument to the block.
+  #
+  #   RubyPython::PyMain.dir("dir") { |a| a.rubify.map { |e| e.to_sym } }
+  #     # => [:__add__, :__class__, :__contains__, … ]
+  class PyMainClass < RubyPython::BlankObject
+    include Singleton
+
+    # Returns a proxy object wrapping the \Python <tt>__main__</tt> namespace.
+    def main
+      @main ||= RubyPython.import "__main__"
+    end
+
+    # Returns a proxy object wrapping the \Python <tt>__builtin__</tt>
+    # namespace.
+    def builtin
+      @builtin ||= RubyPython.import "__builtin__"
+    end
+
+    # Delegates any method calls on this object to the \Python
+    # <tt>__main__</tt> or <tt>__builtin__</tt> namespaces, in that order. If
+    # a block is provided, the result of calling the \Python method will be
+    # yielded as an argument to the block.
+    #
+    # [name] The name of the \Python method or function to call.
+    # [args] The arguments to pass to the \Python method.
+    # [block] A block to execute with the result of calling the \Python
+    # method. If a block is provided, the result of the block is returned,
+    # not the result of the \Python method.
+    def method_missing(name, *args, &block)
+      proxy = if main.respond_to?(name)
+                main
+              elsif builtin.respond_to?(name)
+                builtin
+              else
+                super(name, *args)
+              end
+      result = if proxy.is_real_method?(name)
+                 proxy.__send__(name, *args)
+               else
+                 proxy.__send__(:method_missing, name, *args)
+               end
+
+      if block
+        block.call(result)
+      else
+        result
+      end
+    end
+
+    # Called by RubyPython when the interpreter is started or stopped so
+    # that the neccesary preparation or cleanup can be done. For internal
+    # use only.
+    def python_interpreter_update(status)
+      case status
+      when :stop
+        @main = nil
+        @builtin = nil
+      end
+    end
+    private :python_interpreter_update
+  end
+
+  # The accessible instance of PyMainClass.
+  PyMain = RubyPython::PyMainClass.instance
+end