Merge pull request #72 from mrkn/getattr

Introduce easy ways to get functional attributes

This fixes #67

Author: mrkn

lib/pycall.rb

@@ -4,6 +4,7 @@ module PyCall
   require 'pycall/pyerror'
   require 'pycall/pyobject_wrapper'
   require 'pycall/pytypeobject_wrapper'
+  require 'pycall/pymodule_wrapper'
   require 'pycall/init'
 
   module_function
@@ -48,6 +49,15 @@ def exec(code, globals: nil, locals: nil)
     end
   end
 
+  def getattr(*args)
+    obj, *rest = args
+    LibPython::Helpers.getattr(obj.__pyptr__, *rest)
+  end
+
+  def hasattr?(obj, name)
+    LibPython::Helpers.hasattr?(obj.__pyptr__, name)
+  end
+
   def import_module(name)
     LibPython::Helpers.import_module(name)
   end

lib/pycall/pymodule_wrapper.rb

@@ -0,0 +1,46 @@
+require 'pycall/pyobject_wrapper'
+
+module PyCall
+  module PyModuleWrapper
+    include PyObjectWrapper
+
+    def [](*args)
+      case args[0]
+      when String, Symbol
+        PyCall.getattr(self, args[0])
+      else
+        super
+      end
+    end
+  end
+
+  module_function
+
+  class WrapperModuleCache < WrapperObjectCache
+    def initialize
+      super(LibPython::API::PyModule_Type)
+    end
+
+    def check_wrapper_object(wrapper_object)
+      unless wrapper_object.kind_of?(Module) && wrapper_object.kind_of?(PyObjectWrapper)
+        raise TypeError, "unexpected type #{wrapper_object.class} (expected Module extended by PyObjectWrapper)"
+      end
+    end
+
+    def self.instance
+      @instance ||= self.new
+    end
+  end
+
+  private_constant :WrapperModuleCache
+
+  def wrap_module(pymodptr)
+    check_ismodule(pymodptr)
+    WrapperModuleCache.instance.lookup(pymodptr) do
+      Module.new do |mod|
+        mod.instance_variable_set(:@__pyptr__, pymodptr)
+        mod.extend PyModuleWrapper
+      end
+    end
+  end
+end

lib/pycall/pyobject_wrapper.rb

@@ -170,32 +170,9 @@ def to_f
 
   module_function
 
-  class WrapperModuleCache < WrapperObjectCache
-    def initialize
-      super(LibPython::API::PyModule_Type)
-    end
-
-    def check_wrapper_object(wrapper_object)
-      unless wrapper_object.kind_of?(Module) && wrapper_object.kind_of?(PyObjectWrapper)
-        raise TypeError, "unexpected type #{wrapper_object.class} (expected Module extended by PyObjectWrapper)"
-      end
-    end
-
-    def self.instance
-      @instance ||= self.new
-    end
-  end
-
-  private_constant :WrapperModuleCache
-
-  def wrap_module(pymodptr)
-    check_ismodule(pymodptr)
-    WrapperModuleCache.instance.lookup(pymodptr) do
-      Module.new do |mod|
-        mod.instance_variable_set(:@__pyptr__, pymodptr)
-        mod.extend PyObjectWrapper
-      end
-    end
+  def check_ismodule(pyptr)
+    return if pyptr.kind_of? LibPython::API::PyModule_Type
+    raise TypeError, "PyModule object is required"
   end
 
   def check_isclass(pyptr)
@@ -204,9 +181,4 @@ def check_isclass(pyptr)
     return defined?(LibPython::API::PyClass_Type) && pyptr.kind_of?(LibPython::API::PyClass_Type)
     raise TypeError, "PyType object is required"
   end
-
-  def check_ismodule(pyptr)
-    return if pyptr.kind_of? LibPython::API::PyModule_Type
-    raise TypeError, "PyModule object is required"
-  end
 end

spec/pycall/pymodule_wrapper_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+::RSpec.describe PyCall::PyModuleWrapper do
+  let(:simple_module) do
+    PyCall.import_module('pycall.simple_module')
+  end
+
+  specify do
+    expect(simple_module).to be_an_instance_of(Module)
+    expect(simple_module).to be_a(PyCall::PyModuleWrapper)
+    expect(simple_module).to be_a(PyCall::PyObjectWrapper)
+  end
+
+  describe '#[]' do
+    specify do
+      expect(simple_module[:double]).to be_a(PyCall::PyObjectWrapper)
+      expect(simple_module[:double].call(2)).to eq(4)
+      expect(simple_module[:answer]).to eq(42)
+    end
+  end
+end

spec/pycall_spec.rb

@@ -48,6 +48,28 @@
     end
   end
 
+  describe '.getattr' do
+    let(:pyobj) { PyCall.import_module('pycall.simple_module') }
+
+    specify do
+      expect(PyCall.getattr(pyobj, :answer)).to eq(42)
+      expect {
+        PyCall.getattr(pyobj, :absent_name)
+      }.to raise_error(PyCall::PyError, /AttributeError/)
+      o = Object.new
+      expect(PyCall.getattr(pyobj, :absent_name, o)).to equal(o)
+    end
+  end
+
+  describe '.hasattr?' do
+    let(:pyobj) { PyCall.import_module('pycall.simple_module') }
+
+    specify do
+      expect(PyCall.hasattr?(pyobj, :answer)).to eq(true)
+      expect(PyCall.hasattr?(pyobj, :absent_name)).to eq(false)
+    end
+  end
+
   describe '.import_module' do
     subject { PyCall.import_module('sys') }
 

spec/python/pycall/simple_module.py

@@ -0,0 +1,4 @@
+def double(x):
+    return 2 * x
+
+answer = 42