home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1717 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  3.7 KB  |  160 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import __builtin__
  5. import imp
  6. import sys
  7.  
  8. def deep_import_hook(name, globals = None, locals = None, fromlist = None, level = -1):
  9.     parent = determine_parent(globals)
  10.     (q, tail) = find_head_package(parent, name)
  11.     m = load_tail(q, tail)
  12.     if not fromlist:
  13.         return q
  14.     if hasattr(m, '__path__'):
  15.         ensure_fromlist(m, fromlist)
  16.     
  17.     return m
  18.  
  19.  
  20. def determine_parent(globals):
  21.     if not globals or not globals.has_key('__name__'):
  22.         return None
  23.     pname = globals['__name__']
  24.     if globals.has_key('__path__'):
  25.         parent = sys.modules[pname]
  26.         return parent
  27.     if '.' in pname:
  28.         i = pname.rfind('.')
  29.         pname = pname[:i]
  30.         parent = sys.modules[pname]
  31.         return parent
  32.  
  33.  
  34. def find_head_package(parent, name):
  35.     if '.' in name:
  36.         i = name.find('.')
  37.         head = name[:i]
  38.         tail = name[i + 1:]
  39.     else:
  40.         head = name
  41.         tail = ''
  42.     if parent:
  43.         qname = '%s.%s' % (parent.__name__, head)
  44.     else:
  45.         qname = head
  46.     q = import_module(head, qname, parent)
  47.     if q:
  48.         return (q, tail)
  49.     raise ImportError, 'No module named ' + qname
  50.  
  51.  
  52. def load_tail(q, tail):
  53.     m = q
  54.     while tail:
  55.         i = tail.find('.')
  56.         if i < 0:
  57.             i = len(tail)
  58.         
  59.         head = tail[:i]
  60.         tail = tail[i + 1:]
  61.         mname = m.__name__
  62.         m = import_module(head, mname, m)
  63.         if not m:
  64.             raise ImportError, 'No module named ' + mname
  65.         m
  66.     return m
  67.  
  68.  
  69. def ensure_fromlist(m, fromlist, recursive = 0):
  70.     for sub in fromlist:
  71.         if sub == '*':
  72.             if not recursive:
  73.                 
  74.                 try:
  75.                     all = m.__all__
  76.                 except AttributeError:
  77.                     pass
  78.  
  79.                 ensure_fromlist(m, all, 1)
  80.                 continue
  81.             continue
  82.         
  83.         if sub != '*' and not hasattr(m, sub):
  84.             subname = '%s.%s' % (m.__name__, sub)
  85.             submod = import_module(sub, subname, m)
  86.             if not submod:
  87.                 raise ImportError, 'No module named ' + subname
  88.             submod
  89.             continue
  90.     
  91.  
  92. found_now = { }
  93.  
  94. def import_module(partname, fqname, parent):
  95.     if found_now.has_key(fqname):
  96.         
  97.         try:
  98.             return sys.modules[fqname]
  99.         except KeyError:
  100.             pass
  101.         except:
  102.             None<EXCEPTION MATCH>KeyError
  103.         
  104.  
  105.     None<EXCEPTION MATCH>KeyError
  106.     print 'Reloading', fqname
  107.     found_now[fqname] = 1
  108.     
  109.     try:
  110.         if parent:
  111.             pass
  112.         (fp, pathname, stuff) = imp.find_module(partname, parent.__path__)
  113.     except ImportError:
  114.         return None
  115.  
  116.     
  117.     try:
  118.         m = imp.load_module(fqname, fp, pathname, stuff)
  119.     finally:
  120.         if fp:
  121.             fp.close()
  122.         
  123.  
  124.     if parent:
  125.         setattr(parent, partname, m)
  126.     
  127.     return m
  128.  
  129.  
  130. def deep_reload_hook(module):
  131.     name = module.__name__
  132.     if '.' not in name:
  133.         return import_module(name, name, None)
  134.     i = name.rfind('.')
  135.     pname = name[:i]
  136.     parent = sys.modules[pname]
  137.     return import_module(name[i + 1:], name, parent)
  138.  
  139. original_reload = __builtin__.reload
  140.  
  141. def reload(module, exclude = [
  142.     'sys',
  143.     '__builtin__',
  144.     '__main__']):
  145.     global found_now
  146.     for i in exclude:
  147.         found_now[i] = 1
  148.     
  149.     original_import = __builtin__.__import__
  150.     __builtin__.__import__ = deep_import_hook
  151.     
  152.     try:
  153.         ret = deep_reload_hook(module)
  154.     finally:
  155.         __builtin__.__import__ = original_import
  156.         found_now = { }
  157.  
  158.     return ret
  159.  
  160.