rewrite of pyximport module based on PEP 302 import hooks

pyximport/pyximport.py

 """
-Import hooks; when installed (with the install()) function, these hooks 
+Import hooks; when installed with the install() function, these hooks 
 allow importing .pyx files as if they were Python modules.
 
 If you want the hook installed every time you run Python
 you can add it to your Python version by adding these lines to
 sitecustomize.py (which you can create from scratch in site-packages 
-if it doesn't exist there are somewhere else on your python path)
+if it doesn't exist there or somewhere else on your python path)::
 
-import pyximport
-pyximport.install()
+    import pyximport
+    pyximport.install()
 
-For instance on  the Mac with Python 2.3 built from CVS, you could 
-create sitecustomize.py with only those two lines at
+For instance on the Mac with a non-system Python 2.3, you could create
+sitecustomize.py with only those two lines at
 /usr/local/lib/python2.3/site-packages/sitecustomize.py .
 
 Running this module as a top-level script will run a test and then print
 the documentation.
 
-This code was modeled on Quixote's ptl_import.
+This code is based on the Py2.3+ import protocol as described in PEP 302.
 """
-import sys, os, shutil
-import imp, ihooks, glob
-import __builtin__
+import sys
+import os
+import glob
+import imp
 import pyxbuild
 from distutils.dep_util import newer
 from distutils.extension import Extension
@@ -33,19 +34,11 @@ except ImportError:
 
 mod_name = "pyximport"
 
-assert sys.hexversion >= 0x20000b1, "need Python 2.0b1 or later"
+assert sys.hexversion >= 0x2030000, "need Python 2.3 or later"
 
-PYX_FILE_TYPE = 1011
 PYX_EXT = ".pyx"
 PYXDEP_EXT = ".pyxdep"
 PYXBLD_EXT = ".pyxbld"
-_test_files = []
-
-class PyxHooks (ihooks.Hooks):
-    """Import hook that declares our suffixes. Let install() install it."""
-    def get_suffixes (self):
-        # add our suffixes
-        return imp.get_suffixes() + [(PYX_EXT, "r", PYX_FILE_TYPE)]
 
 # Performance problem: for every PYX file that is imported, we will 
 # invoke the whole distutils infrastructure even if the module is 
@@ -58,15 +51,11 @@ def _load_pyrex(name, filename):
     "Load a pyrex file given a name and filename."
 
 def get_distutils_extension(modname, pyxfilename):
-
     extra = "_" + hashlib.md5(open(pyxfilename).read()).hexdigest()  
 #    modname = modname + extra
-
     extension_mod = handle_special_build(modname, pyxfilename)
-
     if not extension_mod:
         extension_mod = Extension(name = modname, sources=[pyxfilename])
-
     return extension_mod
 
 def handle_special_build(modname, pyxfilename):
@@ -147,53 +136,64 @@ def load_module(name, pyxfilename):
     assert mod.__file__ == so_path, (mod.__file__, so_path)
     return mod
 
-class PyxLoader (ihooks.ModuleLoader):
-    """Load a module. It checks whether a file is a .pyx and returns it.
-    Otherwise it lets the ihooks base class handle it. Let install() 
-    install it."""
-
-    def load_module (self, name, stuff):
-        # If it's a Pyrex file, load it specially.
-        if stuff[2][2] == PYX_FILE_TYPE:
-            file, pyxfilename, info = stuff
-            (suff, mode, type) = info
-            if file:
-                file.close()
-	    return load_module(name, pyxfilename)
-        else:
-            # Otherwise, use the default handler for loading
-            return ihooks.ModuleLoader.load_module( self, name, stuff)
 
-try:
-    import cimport
-except ImportError:
-    cimport = None
-
-class cModuleImporter(ihooks.ModuleImporter):
-    """This was just left in from the Quixote implementation. I think
-    it allows a performance enhancement if you have the cimport module
-    from Quixote. Let install() install it."""
-    def __init__(self, loader=None):
-        self.loader = loader or ihooks.ModuleLoader()
-        cimport.set_loader(self.find_import_module)
-
-    def find_import_module(self, fullname, subname, path):
-        stuff = self.loader.find_module(subname, path)
-        if not stuff:
+# import hooks
+
+class PyxImporter(object):
+    def __init__(self, so_cache_dir):
+        self.so_cache_dir = so_cache_dir
+        self.so_name_cache = {}
+
+    def find_module(self, fullname, package_path=None):
+        print "SEARCHING", fullname, package_path
+        if '.' in fullname:
+            mod_parts = fullname.split('.')
+            package = '.'.join(mod_parts[:-1])
+            module_name = mod_parts[-1]
+        else:
+            package = None
+            module_name = fullname
+        pyx_module_name = module_name + PYX_EXT
+        # this may work, but it returns the file content, not its path
+        #import pkgutil
+        #pyx_source = pkgutil.get_data(package, pyx_module_name)
+
+        if package_path:
+            paths = package_path
+        else:
+            paths = sys.path
+        join_path = os.path.join
+        is_file = os.path.isfile
+        for path in filter(os.path.isdir, paths):
+            for filename in os.listdir(path):
+                if filename == pyx_module_name:
+                    return PyxLoader(fullname, join_path(path, filename))
+                elif filename == module_name:
+                    package_path = join_path(path, filename)
+                    init_path = join_path(package_path, '__init__' + PYX_EXT)
+                    if is_file(init_path):
+                        return PyxLoader(fullname, package_path, init_path)
+        # not found, normal package, not a .pyx file, none of our business
         return None
-        return self.loader.load_module(fullname, stuff)
 
-    def install(self):
-        self.save_import_module = __builtin__.__import__
-        self.save_reload = __builtin__.reload
-        if not hasattr(__builtin__, 'unload'):
-            __builtin__.unload = None
-        self.save_unload = __builtin__.unload
-        __builtin__.__import__ = cimport.import_module
-        __builtin__.reload = cimport.reload_module
-        __builtin__.unload = self.unload
+class PyxLoader(object):
+    def __init__(self, fullname, path, init_path=None):
+        self.fullname, self.path, self.init_path = fullname, path, init_path
+
+    def load_module(self, fullname):
+        assert self.fullname == fullname, (
+            "invalid module, expected %s, got %s" % (
+            self.fullname, fullname))
+        if self.init_path:
+            # package
+            print "PACKAGE", fullname
+            module = load_module(fullname, self.init_path)
+            module.__path__ = [self.path]
+        else:
+            print "MODULE", fullname
+            module = load_module(fullname, self.path)
+        return module
 
-_installed = 0
 
 def install():
     """Main entry point. call this to install the import hook in your
@@ -201,22 +201,14 @@ def install():
     you use Python, add it to your sitecustomize (as described above).
 
     """
-    global _installed
-    if not _installed:
-        hooks = PyxHooks()
-        loader = PyxLoader(hooks)
-        if cimport is not None:
-            importer = cModuleImporter(loader)
-        else:
-            importer = ihooks.ModuleImporter(loader)
-        ihooks.install(importer)
-        _installed = 1
-
-def on_remove_file_error(func, path, excinfo):
-    print "Sorry! Could not remove a temp file:", path
-    print "Extra information."
-    print func, excinfo
-    print "You may want to delete this yourself when you get a chance."
+    for importer in sys.meta_path:
+        if isinstance(importer, PyxImporter):
+            return
+    importer = PyxImporter('~/.pyxbuild')
+    sys.meta_path.append(importer)
+
+
+# MAIN
 
 def show_docs():
     import __main__