pybind 0.1.0

data/lib/pybind/utils.rb

@@ -0,0 +1,81 @@
+module PyBind
+  module Utils
+    BUILTIN_FUNCS = %w[
+      getattr hasattr setattr delattr
+      id type dir len iter next
+    ]
+
+    BUILTIN_FUNCS.each do |func|
+      define_method(func) do |*args|
+        PyBind.builtin.get_attribute(func).call(*args)
+      end
+    end
+
+    MODULE_SHORTCUTS = %w[
+      types traceback
+    ]
+
+    MODULE_SHORTCUTS.each do |mod|
+      define_method(mod) do |*args|
+        PyBind.import(mod)
+      end
+    end
+
+    def None
+      LibPython.Py_None
+    end
+
+    def True
+      LibPython.Py_True
+    end
+
+    def False
+      LibPython.Py_False
+    end
+
+    def eval(str)
+      dict = main_dict
+      eval_func = PyBind.builtin.get_attribute('eval')
+      eval_func.call(str, dict, dict)
+    end
+
+    def execfile(filename)
+      dict = main_dict
+      if PyBind.builtin.has_attribute?('execfile')
+        execfile_func = PyBind.builtin.get_attribute('execfile')
+        execfile_func.call(filename, dict, dict)
+      else
+        open_func = PyBind.builtin.get_attribute('open')
+        exec_func = PyBind.builtin.get_attribute('exec')
+        content = open_func.call(filename).get_attribute('read').call()
+        exec_func.(content, dict, dict)
+      end
+    end
+
+    def callable?(pyobj)
+      pystruct = pyobj.to_python_struct
+      LibPython.PyCallable_Check(pystruct) == 1
+    end
+
+    def incref(pyobj)
+      pystruct = pyobj.to_python_struct
+      LibPython.Py_IncRef(pystruct)
+      pyobj
+    end
+
+    def decref(pyobj)
+      pystruct = pyobj.to_python_struct
+      LibPython.Py_DecRef(pystruct)
+      pystruct.send :pointer=, FFI::Pointer::NULL
+      pyobj
+    end
+
+    private
+
+    def main_dict
+      LibPython.PyModule_GetDict(PyBind.import("__main__").to_python_struct).to_ruby
+    end
+  end
+
+  extend Utils
+end

data/lib/pybind/version.rb

@@ -0,0 +1,3 @@
+module PyBind
+  VERSION = '0.1.0'.freeze
+end

data/lib/pybind/wrapper.rb

@@ -0,0 +1,120 @@
+require 'pybind/wrapper/attr_accessor'
+require 'pybind/wrapper/rich_comparer'
+require 'pybind/wrapper/operator'
+
+module PyBind
+  module PyObjectClassMethods
+    def pybind_type(pytype, &block)
+      raise ArgumentError, "#{self} is already bound with #{@pystruct}" if @pystruct
+      define_singleton_method :from_python, &block if block
+      @pystruct = pytype.to_python_struct
+    end
+
+    def python_instance?(pyobj)
+      return false unless @pystruct
+      pystruct = pyobj.to_python_struct
+      value = LibPython.PyObject_IsInstance(pystruct, @pystruct)
+      raise PyError.fetch if value == -1
+      value == 1
+    end
+
+    def python_subclass?(pyobj)
+      return false unless @pystruct
+      pystruct = pyobj.to_python_struct
+      value = LibPython.PyObject_IsSubclass(pystruct, @pystruct)
+      raise PyError.fetch if value == -1
+      value == 1
+    end
+
+    def from_python(pystruct)
+      new(pystruct)
+    end
+
+    def to_python_struct
+      @pystruct
+    end
+    alias_method :python_type, :to_python_struct
+    alias_method :to_python, :to_python_struct
+  end
+
+  module PyClassWrapper
+    def self.included(mod)
+      mod.extend(PyObjectClassMethods)
+      Types.register_type(mod)
+    end
+  end
+
+  module PyObjectWrapper
+    include AttrAccessor
+    include RichComparer
+    include Operator
+
+    def initialize(pystruct)
+      raise TypeError, "the argument must be a PyObjectStruct" unless pystruct.kind_of? PyObjectStruct
+      @pystruct = pystruct
+    end
+
+    def call(*args, **kwargs)
+      args = PyTuple[*args]
+      kwargs = kwargs.empty? ? PyObject.null : PyDict.new(kwargs)
+      res = LibPython.PyObject_Call(@pystruct, args.to_python_struct, kwargs.to_python_struct)
+      raise PyError.fetch unless LibPython.PyErr_Occurred().null?
+      res.to_ruby
+    end
+
+    def to_s
+      str = LibPython.PyObject_Str(@pystruct)
+      return str.to_ruby unless str.null?
+      super
+    end
+
+    def inspect
+      str = LibPython.PyObject_Repr(@pystruct)
+      return "#<#{self.class.name || python_type} #{str.to_ruby}>" unless str.null?
+      super
+    end
+
+    def methods
+      LibPython.PyObject_Dir(@pystruct).to_ruby.map &:to_sym
+    end
+
+    extend Forwardable
+    def_delegators :@pystruct, :null?, :none?
+
+    def python_type
+      LibPython.PyObject_Type(@pystruct).to_ruby
+    end
+
+    def to_python_struct
+      @pystruct
+    end
+    alias_method :to_python, :to_python_struct
+
+    def self.included(mod)
+      mod.extend(PyObjectClassMethods)
+      Types.register_type(mod)
+    end
+
+    private
+
+    def method_missing(name, *args, **kwargs)
+      attr_name = name.to_s
+      is_setter = attr_name.end_with?("=")
+      attr_name = attr_name.chomp('=') if is_setter
+
+      if has_attribute?(attr_name)
+        if is_setter
+          set_attribute(attr_name, *args)
+        else
+          autocall_method_missing(get_attribute(attr_name), *args, **kwargs)
+        end
+      else
+        super
+      end
+    end
+
+    def autocall_method_missing(value, *args, **kwargs)
+      value
+    end
+  end
+end

data/lib/pybind/wrapper/attr_accessor.rb

@@ -0,0 +1,53 @@
+module PyBind
+  module AttrAccessor
+    def get_attribute(name, default = nil)
+      value = LibPython.PyObject_GetAttrString(@pystruct, name.to_s)
+      if value.null?
+        raise PyError.fetch unless default
+        return default
+      end
+      value.to_ruby
+    end
+
+    def set_attribute(name, value)
+      value = value.to_python
+      ret = LibPython.PyObject_SetAttrString(@pystruct, name.to_s, value)
+      raise PyError.fetch if ret == -1
+      self
+    end
+
+    def remove_attribute(name)
+      value = LibPython.PyObject_GetAttrString(@pystruct, name.to_s)
+      raise PyError.fetch if value.null?
+      ret = if LibPython.respond_to? :PyObject_DelAttrString
+          LibPython.PyObject_DelAttrString(@pystruct, name.to_s)
+        else
+          LibPython.PyObject_SetAttrString(@pystruct, name.to_s, PyBind.None)
+        end
+      raise PyError.fetch if ret == -1
+      value.to_ruby
+    end
+
+    def has_attribute?(name)
+      LibPython.PyObject_HasAttrString(@pystruct, name.to_s) == 1
+    end
+
+    def [](*indices)
+      key = TypeCast.to_python_arguments(indices)
+      value = LibPython.PyObject_GetItem(@pystruct, key)
+      raise PyError.fetch if value.null?
+      value.to_ruby
+    end
+
+    def []=(*indices_and_value)
+      value = indices_and_value.pop
+      indices = indices_and_value
+      key = TypeCast.to_python_arguments(indices)
+      value = value.to_python
+      ret = LibPython.PyObject_SetItem(@pystruct, pykey, value)
+      raise PyError.fetch if ret == -1
+      self
+    end
+
+  end
+end

data/lib/pybind/wrapper/operator.rb

@@ -0,0 +1,82 @@
+module PyBind
+  module Operator
+    BINARY_OPERATION_OPFUNCS = {
+      :+ => :PyNumber_Add,
+      :- => :PyNumber_Subtract,
+      :* => :PyNumber_Multiply,
+      :/ => :PyNumber_TrueDivide,
+      :% => :PyNumber_Remainder,
+      :<< => :PyNumber_Lshift,
+      :>> => :PyNumber_Rshift,
+      :& => :PyNumber_And,
+      :^ => :PyNumber_Xor,
+      :| => :PyNumber_Or
+    }.freeze
+
+    UNARY_OPERATION_OPFUNCS = {
+      :+@ => :PyNumber_Positive,
+      :-@ => :PyNumber_Negative,
+      :~ => :PyNumber_Invert,
+    }.freeze
+
+    def __binary_operate__(other, op)
+      opfunc = BINARY_OPERATION_OPFUNCS[op]
+      raise ArgumentError, "Unknown binary operation op: #{op}" unless opfunc
+
+      other = other.to_python
+      value = LibPython.send(opfunc, @pystruct, other)
+      raise PyError.fetch if value.null?
+      value.to_ruby
+    end
+
+    BINARY_OPERATION_OPFUNCS.keys.each do |op|
+      define_method(op) do |other|
+        __binary_operate__(other, op)
+      end
+    end
+
+    def __unary_operate__(op)
+      opfunc = UNARY_OPERATION_OPFUNCS[op]
+      raise ArgumentError, "Unknown unary operation op: #{op}" unless opfunc
+
+      value = LibPython.send(opfunc, @pystruct)
+      raise PyError.fetch if value.null?
+      value.to_ruby
+    end
+
+    UNARY_OPERATION_OPFUNCS.keys.each do |op|
+      define_method(op) do |other|
+        __unary_operate__(op)
+      end
+    end
+
+    def **(other)
+      other = other.to_python
+      value = LibPython.PyNumber_Power(@pystruct, other, PyBind.None)
+      raise PyError.fetch if value.null?
+      value.to_ruby
+    end
+
+    def <=>(other)
+      if LibPython.respond_to? :PyObject_Compare
+        other = other.to_python
+        value = LibPython.PyObject_Compare(@pystruct, other)
+        raise PyError.fetch unless LibPython.PyErr_Occurred().null?
+        value
+      else
+        (self > other) - (self < other)
+      end
+    end
+
+    def ===(other)
+      other = other.to_python
+      @pystruct.to_ptr == other.to_ptr
+    end
+
+    def !
+      value = LibPython.PyObject_Not(@pystruct)
+      raise PyError.fetch if value == -1
+      value == 1
+    end
+  end
+end

data/lib/pybind/wrapper/rich_comparer.rb

@@ -0,0 +1,39 @@
+module PyBind
+  module RichComparer
+    Py_LT = 0
+    Py_LE = 1
+    Py_EQ = 2
+    Py_NE = 3
+    Py_GT = 4
+    Py_GE = 5
+
+    RICH_COMPARISON_OPCODES = {
+      :<  => Py_LT,
+      :<= => Py_LE,
+      :== => Py_EQ,
+      :!= => Py_NE,
+      :>  => Py_GT,
+      :>= => Py_GE
+    }.freeze
+
+    def __rich_compare__(other, op)
+      opcode = RICH_COMPARISON_OPCODES[op]
+      raise ArgumentError, "Unknown comparison op: #{op}" unless opcode
+
+      other = other.to_python
+      return other.null? if @pystruct.null?
+      return false if other.null?
+
+      value = LibPython.PyObject_RichCompare(@pystruct, other, opcode)
+      raise PyError.fetch if value.null?
+      value.to_ruby
+    end
+
+    RICH_COMPARISON_OPCODES.keys.each do |op|
+      define_method(op) do |other|
+        __rich_compare__(other, op)
+      end
+    end
+
+  end
+end

data/pybind.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pybind/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'pybind'
+  spec.version       = PyBind::VERSION
+  spec.authors       = ['Theo Li']
+  spec.email         = ['bbtfrr@gmail.com']
+
+  spec.summary       = 'Seamless operability between Ruby and Python'
+  spec.description   = 'Seamless operability between Ruby and Python'
+  spec.homepage      = 'https://github.com/bbtfr/pybind'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ffi'
+
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry', '~> 0.10.4'
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: pybind
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Theo Li
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+description: Seamless operability between Ruby and Python
+email:
+- bbtfrr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/autocall_functions.rb
+- examples/hello_world.py
+- examples/hello_world.rb
+- examples/mnist.softmax.rb
+- examples/numpy.rb
+- lib/pybind.rb
+- lib/pybind/autocall.rb
+- lib/pybind/core_ext/basic.rb
+- lib/pybind/error.rb
+- lib/pybind/import.rb
+- lib/pybind/init.rb
+- lib/pybind/libpython.rb
+- lib/pybind/python/investigator.py
+- lib/pybind/struct.rb
+- lib/pybind/typecast.rb
+- lib/pybind/types.rb
+- lib/pybind/types/basic.rb
+- lib/pybind/types/dict.rb
+- lib/pybind/types/function.rb
+- lib/pybind/types/list.rb
+- lib/pybind/types/object.rb
+- lib/pybind/types/sequence.rb
+- lib/pybind/types/set.rb
+- lib/pybind/types/slice.rb
+- lib/pybind/types/tuple.rb
+- lib/pybind/utils.rb
+- lib/pybind/version.rb
+- lib/pybind/wrapper.rb
+- lib/pybind/wrapper/attr_accessor.rb
+- lib/pybind/wrapper/operator.rb
+- lib/pybind/wrapper/rich_comparer.rb
+- pybind.gemspec
+homepage: https://github.com/bbtfr/pybind
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Seamless operability between Ruby and Python
+test_files: []