home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_668 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  11.3 KB  |  495 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import sys
  6. import imp
  7. import os.path as os
  8. from types import ModuleType
  9. __all__ = [
  10.     'get_importer',
  11.     'iter_importers',
  12.     'get_loader',
  13.     'find_loader',
  14.     'walk_packages',
  15.     'iter_modules',
  16.     'ImpImporter',
  17.     'ImpLoader',
  18.     'read_code',
  19.     'extend_path']
  20.  
  21. def read_code(stream):
  22.     import marshal
  23.     magic = stream.read(4)
  24.     if magic != imp.get_magic():
  25.         return None
  26.     stream.read(4)
  27.     return marshal.load(stream)
  28.  
  29.  
  30. def simplegeneric(func):
  31.     registry = { }
  32.     
  33.     def wrapper(*args, **kw):
  34.         ob = args[0]
  35.         
  36.         try:
  37.             cls = ob.__class__
  38.         except AttributeError:
  39.             cls = type(ob)
  40.  
  41.         
  42.         try:
  43.             mro = cls.__mro__
  44.         except AttributeError:
  45.             
  46.             try:
  47.                 
  48.                 class cls(cls, object):
  49.                     pass
  50.  
  51.                 mro = cls.__mro__[1:]
  52.             except TypeError:
  53.                 mro = (object,)
  54.             except:
  55.                 None<EXCEPTION MATCH>TypeError
  56.             
  57.  
  58.             None<EXCEPTION MATCH>TypeError
  59.  
  60.         for t in mro:
  61.             if t in registry:
  62.                 return registry[t](*args, **kw)
  63.         else:
  64.             return func(*args, **kw)
  65.         return t in registry
  66.  
  67.     
  68.     try:
  69.         wrapper.__name__ = func.__name__
  70.     except (TypeError, AttributeError):
  71.         (None, None)
  72.         (None, None)
  73.     except:
  74.         (None, None)
  75.  
  76.     
  77.     def register(typ, func = ((None, None), None)):
  78.         if func is None:
  79.             return (lambda f: register(typ, f))
  80.         registry[typ] = func
  81.         return func
  82.  
  83.     wrapper.__dict__ = func.__dict__
  84.     wrapper.__doc__ = func.__doc__
  85.     wrapper.register = register
  86.     return wrapper
  87.  
  88.  
  89. def walk_packages(path = None, prefix = '', onerror = None):
  90.     
  91.     def seen(p, m = { }):
  92.         if p in m:
  93.             return True
  94.         m[p] = True
  95.  
  96.     for importer, name, ispkg in iter_modules(path, prefix):
  97.         yield (importer, name, ispkg)
  98.         if ispkg:
  99.             
  100.             try:
  101.                 __import__(name)
  102.             except ImportError:
  103.                 if onerror is not None:
  104.                     onerror(name)
  105.                 
  106.             except Exception:
  107.                 if onerror is not None:
  108.                     onerror(name)
  109.                 else:
  110.                     raise 
  111.                 onerror is not None
  112.  
  113.             if not getattr(sys.modules[name], '__path__', None):
  114.                 pass
  115.             path = []
  116.             path = _[1]
  117.             for item in walk_packages(path, name + '.', onerror):
  118.                 yield item
  119.                 []
  120.             
  121.         []
  122.     
  123.  
  124.  
  125. def iter_modules(path = None, prefix = ''):
  126.     if path is None:
  127.         importers = iter_importers()
  128.     else:
  129.         importers = map(get_importer, path)
  130.     yielded = { }
  131.     for i in importers:
  132.         for name, ispkg in iter_importer_modules(i, prefix):
  133.             if name not in yielded:
  134.                 yielded[name] = 1
  135.                 yield (i, name, ispkg)
  136.                 continue
  137.         
  138.     
  139.  
  140.  
  141. def iter_importer_modules(importer, prefix = ''):
  142.     if not hasattr(importer, 'iter_modules'):
  143.         return []
  144.     return importer.iter_modules(prefix)
  145.  
  146. iter_importer_modules = simplegeneric(iter_importer_modules)
  147.  
  148. class ImpImporter:
  149.     
  150.     def __init__(self, path = None):
  151.         self.path = path
  152.  
  153.     
  154.     def find_module(self, fullname, path = None):
  155.         subname = fullname.split('.')[-1]
  156.         if subname != fullname and self.path is None:
  157.             return None
  158.         if self.path is None:
  159.             path = None
  160.         else:
  161.             path = [
  162.                 os.path.realpath(self.path)]
  163.         
  164.         try:
  165.             (file, filename, etc) = imp.find_module(subname, path)
  166.         except ImportError:
  167.             return None
  168.  
  169.         return ImpLoader(fullname, file, filename, etc)
  170.  
  171.     
  172.     def iter_modules(self, prefix = ''):
  173.         if self.path is None or not os.path.isdir(self.path):
  174.             return None
  175.         yielded = { }
  176.         import inspect
  177.         filenames = os.listdir(self.path)
  178.         filenames.sort()
  179.         for fn in filenames:
  180.             modname = inspect.getmodulename(fn)
  181.             if modname == '__init__' or modname in yielded:
  182.                 continue
  183.             
  184.             path = os.path.join(self.path, fn)
  185.             ispkg = False
  186.             if not modname and os.path.isdir(path) and '.' not in fn:
  187.                 modname = fn
  188.                 for fn in os.listdir(path):
  189.                     subname = inspect.getmodulename(fn)
  190.                     if subname == '__init__':
  191.                         ispkg = True
  192.                         break
  193.                         continue
  194.                 
  195.             
  196.             if modname and '.' not in modname:
  197.                 yielded[modname] = 1
  198.                 yield (prefix + modname, ispkg)
  199.                 continue
  200.         
  201.  
  202.  
  203.  
  204. class ImpLoader:
  205.     code = None
  206.     source = None
  207.     
  208.     def __init__(self, fullname, file, filename, etc):
  209.         self.file = file
  210.         self.filename = filename
  211.         self.fullname = fullname
  212.         self.etc = etc
  213.  
  214.     
  215.     def load_module(self, fullname):
  216.         self._reopen()
  217.         
  218.         try:
  219.             mod = imp.load_module(fullname, self.file, self.filename, self.etc)
  220.         finally:
  221.             if self.file:
  222.                 self.file.close()
  223.             
  224.  
  225.         return mod
  226.  
  227.     
  228.     def get_data(self, pathname):
  229.         return open(pathname, 'rb').read()
  230.  
  231.     
  232.     def _reopen(self):
  233.         if self.file and self.file.closed:
  234.             mod_type = self.etc[2]
  235.             if mod_type == imp.PY_SOURCE:
  236.                 self.file = open(self.filename, 'rU')
  237.             elif mod_type in (imp.PY_COMPILED, imp.C_EXTENSION):
  238.                 self.file = open(self.filename, 'rb')
  239.             
  240.         
  241.  
  242.     
  243.     def _fix_name(self, fullname):
  244.         if fullname is None:
  245.             fullname = self.fullname
  246.         elif fullname != self.fullname:
  247.             raise ImportError('Loader for module %s cannot handle module %s' % (self.fullname, fullname))
  248.         
  249.         return fullname
  250.  
  251.     
  252.     def is_package(self, fullname):
  253.         fullname = self._fix_name(fullname)
  254.         return self.etc[2] == imp.PKG_DIRECTORY
  255.  
  256.     
  257.     def get_code(self, fullname = None):
  258.         fullname = self._fix_name(fullname)
  259.         if self.code is None:
  260.             mod_type = self.etc[2]
  261.             if mod_type == imp.PY_SOURCE:
  262.                 source = self.get_source(fullname)
  263.                 self.code = compile(source, self.filename, 'exec')
  264.             elif mod_type == imp.PY_COMPILED:
  265.                 self._reopen()
  266.                 
  267.                 try:
  268.                     self.code = read_code(self.file)
  269.                 finally:
  270.                     self.file.close()
  271.  
  272.             elif mod_type == imp.PKG_DIRECTORY:
  273.                 self.code = self._get_delegate().get_code()
  274.             
  275.         
  276.         return self.code
  277.  
  278.     
  279.     def get_source(self, fullname = None):
  280.         fullname = self._fix_name(fullname)
  281.         if self.source is None:
  282.             mod_type = self.etc[2]
  283.             if mod_type == imp.PY_SOURCE:
  284.                 self._reopen()
  285.                 
  286.                 try:
  287.                     self.source = self.file.read()
  288.                 finally:
  289.                     self.file.close()
  290.  
  291.             elif mod_type == imp.PY_COMPILED:
  292.                 if os.path.exists(self.filename[:-1]):
  293.                     f = open(self.filename[:-1], 'rU')
  294.                     self.source = f.read()
  295.                     f.close()
  296.                 
  297.             elif mod_type == imp.PKG_DIRECTORY:
  298.                 self.source = self._get_delegate().get_source()
  299.             
  300.         
  301.         return self.source
  302.  
  303.     
  304.     def _get_delegate(self):
  305.         return ImpImporter(self.filename).find_module('__init__')
  306.  
  307.     
  308.     def get_filename(self, fullname = None):
  309.         fullname = self._fix_name(fullname)
  310.         mod_type = self.etc[2]
  311.         if self.etc[2] == imp.PKG_DIRECTORY:
  312.             return self._get_delegate().get_filename()
  313.         if self.etc[2] in (imp.PY_SOURCE, imp.PY_COMPILED, imp.C_EXTENSION):
  314.             return self.filename
  315.  
  316.  
  317.  
  318. try:
  319.     import zipimport
  320.     from zipimport import zipimporter
  321.     
  322.     def iter_zipimport_modules(importer, prefix = ''):
  323.         dirlist = zipimport._zip_directory_cache[importer.archive].keys()
  324.         dirlist.sort()
  325.         _prefix = importer.prefix
  326.         plen = len(_prefix)
  327.         yielded = { }
  328.         import inspect
  329.         for fn in dirlist:
  330.             if not fn.startswith(_prefix):
  331.                 continue
  332.             
  333.             fn = fn[plen:].split(os.sep)
  334.             if len(fn) == 2 and fn[1].startswith('__init__.py'):
  335.                 if fn[0] not in yielded:
  336.                     yielded[fn[0]] = 1
  337.                     yield (fn[0], True)
  338.                 
  339.             
  340.             if len(fn) != 1:
  341.                 continue
  342.             
  343.             modname = inspect.getmodulename(fn[0])
  344.             if modname == '__init__':
  345.                 continue
  346.             
  347.             if modname and '.' not in modname and modname not in yielded:
  348.                 yielded[modname] = 1
  349.                 yield (prefix + modname, False)
  350.                 continue
  351.         
  352.  
  353.     iter_importer_modules.register(zipimporter, iter_zipimport_modules)
  354. except ImportError:
  355.     pass
  356.  
  357.  
  358. def get_importer(path_item):
  359.     
  360.     try:
  361.         importer = sys.path_importer_cache[path_item]
  362.     except KeyError:
  363.         for path_hook in sys.path_hooks:
  364.             
  365.             try:
  366.                 importer = path_hook(path_item)
  367.             continue
  368.             except ImportError:
  369.                 continue
  370.             
  371.  
  372.         else:
  373.             importer = None
  374.         sys.path_importer_cache.setdefault(path_item, importer)
  375.     except:
  376.         None<EXCEPTION MATCH>ImportError
  377.  
  378.     if importer is None:
  379.         
  380.         try:
  381.             importer = ImpImporter(path_item)
  382.         except ImportError:
  383.             None<EXCEPTION MATCH>ImportError
  384.             None<EXCEPTION MATCH>ImportError
  385.             importer = None
  386.         except:
  387.             None<EXCEPTION MATCH>ImportError<EXCEPTION MATCH>ImportError
  388.         
  389.  
  390.     None<EXCEPTION MATCH>ImportError
  391.     return importer
  392.  
  393.  
  394. def iter_importers(fullname = ''):
  395.     if fullname.startswith('.'):
  396.         raise ImportError('Relative module names not supported')
  397.     fullname.startswith('.')
  398.     if '.' in fullname:
  399.         pkg = '.'.join(fullname.split('.')[:-1])
  400.         if pkg not in sys.modules:
  401.             __import__(pkg)
  402.         
  403.         if not getattr(sys.modules[pkg], '__path__', None):
  404.             pass
  405.         path = []
  406.     else:
  407.         for importer in sys.meta_path:
  408.             yield importer
  409.         
  410.         path = sys.path
  411.     for item in path:
  412.         yield get_importer(item)
  413.     
  414.     if '.' not in fullname:
  415.         yield ImpImporter()
  416.     
  417.  
  418.  
  419. def get_loader(module_or_name):
  420.     if module_or_name in sys.modules:
  421.         module_or_name = sys.modules[module_or_name]
  422.     
  423.     if isinstance(module_or_name, ModuleType):
  424.         module = module_or_name
  425.         loader = getattr(module, '__loader__', None)
  426.         if loader is not None:
  427.             return loader
  428.         fullname = module.__name__
  429.     else:
  430.         fullname = module_or_name
  431.     return find_loader(fullname)
  432.  
  433.  
  434. def find_loader(fullname):
  435.     for importer in iter_importers(fullname):
  436.         loader = importer.find_module(fullname)
  437.         if loader is not None:
  438.             return loader
  439.     
  440.  
  441.  
  442. def extend_path(path, name):
  443.     if not isinstance(path, list):
  444.         return path
  445.     pname = os.path.join(*name.split('.'))
  446.     sname = os.extsep.join(name.split('.'))
  447.     sname_pkg = sname + os.extsep + 'pkg'
  448.     init_py = '__init__' + os.extsep + 'py'
  449.     path = path[:]
  450.     for dir in sys.path:
  451.         if not isinstance(dir, basestring) or not os.path.isdir(dir):
  452.             continue
  453.         
  454.         subdir = os.path.join(dir, pname)
  455.         initfile = os.path.join(subdir, init_py)
  456.         if subdir not in path and os.path.isfile(initfile):
  457.             path.append(subdir)
  458.         
  459.         pkgfile = os.path.join(dir, sname_pkg)
  460.         if os.path.isfile(pkgfile):
  461.             
  462.             try:
  463.                 f = open(pkgfile)
  464.             except IOError:
  465.                 msg = None
  466.                 sys.stderr.write("Can't open %s: %s\n" % (pkgfile, msg))
  467.  
  468.             for line in f:
  469.                 line = line.rstrip('\n')
  470.                 if not line or line.startswith('#'):
  471.                     continue
  472.                 
  473.                 path.append(line)
  474.             
  475.             f.close()
  476.             continue
  477.     
  478.     return path
  479.  
  480.  
  481. def get_data(package, resource):
  482.     loader = get_loader(package)
  483.     if loader is None or not hasattr(loader, 'get_data'):
  484.         return None
  485.     if not sys.modules.get(package):
  486.         pass
  487.     mod = loader.load_module(package)
  488.     if mod is None or not hasattr(mod, '__file__'):
  489.         return None
  490.     parts = resource.split('/')
  491.     parts.insert(0, os.path.dirname(mod.__file__))
  492.     resource_name = os.path.join(*parts)
  493.     return loader.get_data(resource_name)
  494.  
  495.