experimenting with using meta module loader for importing julia modules/functions

Author: jakebolewski

julia/__init__.py

@@ -1,8 +1,86 @@
 import sys
-from .core import Julia
+import imp
+import keyword
 
-#initialize julia interpreter
+from .core import Julia, JuliaModule, JuliaError
+
+# initialize julia interpreter
 julia = Julia()
 
-#monkeypatch julia interpreter into module load path
-sys.modules["julia"] = julia
+# monkeypatch julia interpreter into module load path
+#sys.modules["julia"] = julia
+
+# add custom import behavior for the julia "module"
+class JuliaImporter(object):
+
+    def find_module(self, fullname, path=None):
+        print((fullname, path))
+        if path is None:
+            pass
+        if fullname.startswith("julia"):
+            return JuliaModuleLoader()
+        else:
+           return None
+
+
+def ismacro(name):
+    return name.startswith("@")
+
+
+def isoperator(name):
+    return not name[0].isalpha()
+
+
+def isprotected(name):
+    return name.startswith("_")
+
+
+def notascii(name):
+    try:
+        name.encode("ascii")
+        return False
+    except:
+        return True
+
+
+def isamodule(julia_name):
+    return julia.eval("isa({}, Module)".format(julia_name))
+
+
+class JuliaModuleLoader(object):
+
+    def load_module(self, fullname):
+        juliapath = fullname.lstrip("julia.")
+        if isamodule(juliapath):
+            mod = sys.modules.setdefault(fullname, JuliaModule(fullname))
+            mod.__loader__ = self
+            names = julia.eval("names({})".format(juliapath))
+            for name in names:
+                if ismacro(name) or isoperator(name) or isprotected(name) or notascii(name):
+                    continue
+                attrname = name
+                if name.endswith("!"):
+                    attrname = name.rstrip("!") + "_b"
+                if keyword.iskeyword(name):
+                    attrname = "jl".join(name)
+                try:
+                    module_path = ".".join((juliapath, name))
+                    module_obj = julia.eval(module_path)
+                    is_module = julia.eval("isa({}, Module)".format(module_path))
+                    if is_module:
+                        split_path = module_path.split(".")
+                        is_base = split_path[-1] == "Base"
+                        recur_module = split_path[-1] == split_path[-2]
+                        if is_module and not is_base and not recur_module:
+                            newpath = ".".join((fullname, name))
+                            module_obj = self.load_module(newpath)
+                    is_function = julia.eval("isa({}, Function)".format(module_path))
+                    if is_function:
+                        pass
+                    setattr(mod, attrname, module_obj)
+                except Exception:
+                    # some names cannot be imported from base
+                    pass
+            return mod
+
+sys.meta_path.append(JuliaImporter())

julia/core.py

@@ -19,13 +19,16 @@
 import os
 import sys
 import keyword
+import imp
 
 from ctypes import c_void_p as void_p
 from ctypes import c_char_p as char_p
 from ctypes import py_object
 
+
 # this is python 3.3 specific
 from types import ModuleType, FunctionType
+
 #-----------------------------------------------------------------------------
 # Classes and funtions
 #-----------------------------------------------------------------------------
@@ -40,7 +43,7 @@ class ModuleChainedDict(ChainMap, dict):
     # http://code.activestate.com/recipes/305268/
     import UserDict
 
-    class ModuleChainedDict(UserDict.DictMixin,dict):
+    class ModuleChainedDict(UserDict.DictMixin, dict):
         """Combine mulitiple mappings for seq lookup.
         For example, to emulate PYthon's normal lookup sequence:"
         import __builtin__
@@ -59,6 +62,34 @@ def __getitem__(self, key):
             raise KeyError(key)
 
 
+if python_version.major == 3:
+    from io import StringIO
+
+    class JuliaOutput(list):
+
+        def __enter__(self):
+            self._stdout = sys.stdout
+            sys.stdout = self._stringio = StringIO()
+            return self
+
+        def __exit__(self, *args):
+            self.extend(self._stringio.getvalue().splitlines())
+            sys.stdout = self._stdout
+else:
+    from cStringIO import StringIO
+
+    class JuliaOutput(list):
+
+        def __enter__(self):
+            self._stdout = sys.stdout
+            sys.stdout = self._stringio = StringIO()
+            return self
+
+        def __exit__(self, *args):
+            self.extend(self._stringio.getvalue().splitlines())
+            sys.stdout = self._stdout
+
+
 class MetaJuliaModule(type):
     def __new__(meta, name, bases, dict):
         mod = ModuleType(name, dict.get("__doc__"))
@@ -85,7 +116,7 @@ class JuliaError(JuliaObject, Exception):
     pass
 
 
-class JuliaModule(JuliaObject):
+class JuliaModule(ModuleType):
     pass
 
 
@@ -193,11 +224,14 @@ def __init__(self, init_julia=True):
         # reloads.
         sys._julia_runtime = api
         basenames = []
-        for name in self.names(self.Base):
+        names = self.eval("names(Base)")
+        for name in names:
             if ismacro(name):
                 continue
             if isoperator(name):
                 continue
+            if name.startswith("_"):
+                continue
             if name.endswith("!"):
                 name = name.rstrip("!") + "_b"
             if keyword.iskeyword(name):
@@ -237,20 +271,27 @@ def help(self, name):
             return None
         self.eval('help("{}")'.format(name))
 
-    def methods(self, name):
-        """
-        return methods
-        """
-        if name is None:
-            return None
-        print(self.eval("string(methods({}))".format(name)))
-
     def put(self, x):
         pass
 
     def get(self, x):
         pass
 
+    def _ismodule(self, julia_name):
+        return self.eval("isa({}, Module)".format(julia_name))
+        #return self.isa(pycallobj, self.Module)
+
+    def _isfunction(self, pycallobj):
+        return self.isa(pycallobj, self.Function)
+
+    def _isimmutabletype(self, pycallobj):
+        return (self.isa(pycallobj, self.DataType) and
+                self.isimmutable(pycallobj))
+
+    def _isdatatype(self, pycallobj):
+        return (self.isa(pycallobj, self.DataType) and not
+                self.isimmutable(pycallobj))
+
     def __getattr__(self, attr):
         if attr is None:
             return None
@@ -266,10 +307,34 @@ def __getattr__(self, attr):
         else:
             julia_name = attr
         try:
-            obj = self.eval(julia_name)
-            setattr(self, attr, obj)
-            return obj
-        except:
+            #import ipdb; ipdb.set_trace()
+            jobj = self.eval(julia_name)
+            #if self._isfunction(jobj):
+            #    func = JuliaFunction(jobj)
+            #    pyobj = jobj
+            #elif self._isdatatype(jobj):
+            #    pyobj = jobj
+            #elif self._isimmutabletype(jobj):
+            #    pyobj = jobj
+            if self._ismodule(julia_name):
+                names = self.eval("names({})".format(julia_name))
+                #module = JuliaModule(julia_name)
+                module = imp.new_module(julia_name)
+                #for name in dir(jobj):
+                #    try:
+                #        setattr(module, name, getattr(jobj, name))
+                #    except:
+                #        pass
+                for name in names:
+                    mobj = self.eval("{}.{}".format(julia_name, name))
+                    setattr(module, name, mobj)
+                #sys.modules["julia.{}".format(julia_name)] = module
+                return module
+
+            setattr(self, attr, jobj)
+            return jobj
+        except Exception as err:
+            #raise err
             raise AttributeError(attr)
 
     def eval(self, src):