home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_600 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  15.2 KB  |  566 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from warnings import warnpy3k
  5. warnpy3k('the ihooks module has been removed in Python 3.0', stacklevel = 2)
  6. del warnpy3k
  7. import __builtin__
  8. import imp
  9. import os
  10. import sys
  11. __all__ = [
  12.     'BasicModuleLoader',
  13.     'Hooks',
  14.     'ModuleLoader',
  15.     'FancyModuleLoader',
  16.     'BasicModuleImporter',
  17.     'ModuleImporter',
  18.     'install',
  19.     'uninstall']
  20. VERBOSE = 0
  21. from imp import C_EXTENSION, PY_SOURCE, PY_COMPILED
  22. from imp import C_BUILTIN, PY_FROZEN, PKG_DIRECTORY
  23. BUILTIN_MODULE = C_BUILTIN
  24. FROZEN_MODULE = PY_FROZEN
  25.  
  26. class _Verbose:
  27.     
  28.     def __init__(self, verbose = VERBOSE):
  29.         self.verbose = verbose
  30.  
  31.     
  32.     def get_verbose(self):
  33.         return self.verbose
  34.  
  35.     
  36.     def set_verbose(self, verbose):
  37.         self.verbose = verbose
  38.  
  39.     
  40.     def note(self, *args):
  41.         if self.verbose:
  42.             self.message(*args)
  43.         
  44.  
  45.     
  46.     def message(self, format, *args):
  47.         if args:
  48.             print format % args
  49.         else:
  50.             print format
  51.  
  52.  
  53.  
  54. class BasicModuleLoader(_Verbose):
  55.     
  56.     def find_module(self, name, path = None):
  57.         if path is None:
  58.             path = [
  59.                 None] + self.default_path()
  60.         
  61.         for dir in path:
  62.             stuff = self.find_module_in_dir(name, dir)
  63.             if stuff:
  64.                 return stuff
  65.         
  66.  
  67.     
  68.     def default_path(self):
  69.         return sys.path
  70.  
  71.     
  72.     def find_module_in_dir(self, name, dir):
  73.         if dir is None:
  74.             return self.find_builtin_module(name)
  75.         
  76.         try:
  77.             return imp.find_module(name, [
  78.                 dir])
  79.         except ImportError:
  80.             dir is None
  81.             dir is None
  82.             return None
  83.  
  84.  
  85.     
  86.     def find_builtin_module(self, name):
  87.         if imp.is_builtin(name):
  88.             return (None, '', ('', '', BUILTIN_MODULE))
  89.         if imp.is_frozen(name):
  90.             return (None, '', ('', '', FROZEN_MODULE))
  91.  
  92.     
  93.     def load_module(self, name, stuff):
  94.         (file, filename, info) = stuff
  95.         
  96.         try:
  97.             return imp.load_module(name, file, filename, info)
  98.         finally:
  99.             if file:
  100.                 file.close()
  101.             
  102.  
  103.  
  104.  
  105.  
  106. class Hooks(_Verbose):
  107.     
  108.     def get_suffixes(self):
  109.         return imp.get_suffixes()
  110.  
  111.     
  112.     def new_module(self, name):
  113.         return imp.new_module(name)
  114.  
  115.     
  116.     def is_builtin(self, name):
  117.         return imp.is_builtin(name)
  118.  
  119.     
  120.     def init_builtin(self, name):
  121.         return imp.init_builtin(name)
  122.  
  123.     
  124.     def is_frozen(self, name):
  125.         return imp.is_frozen(name)
  126.  
  127.     
  128.     def init_frozen(self, name):
  129.         return imp.init_frozen(name)
  130.  
  131.     
  132.     def get_frozen_object(self, name):
  133.         return imp.get_frozen_object(name)
  134.  
  135.     
  136.     def load_source(self, name, filename, file = None):
  137.         return imp.load_source(name, filename, file)
  138.  
  139.     
  140.     def load_compiled(self, name, filename, file = None):
  141.         return imp.load_compiled(name, filename, file)
  142.  
  143.     
  144.     def load_dynamic(self, name, filename, file = None):
  145.         return imp.load_dynamic(name, filename, file)
  146.  
  147.     
  148.     def load_package(self, name, filename, file = None):
  149.         return imp.load_module(name, file, filename, ('', '', PKG_DIRECTORY))
  150.  
  151.     
  152.     def add_module(self, name):
  153.         d = self.modules_dict()
  154.         if name in d:
  155.             return d[name]
  156.         return m
  157.  
  158.     
  159.     def modules_dict(self):
  160.         return sys.modules
  161.  
  162.     
  163.     def default_path(self):
  164.         return sys.path
  165.  
  166.     
  167.     def path_split(self, x):
  168.         return os.path.split(x)
  169.  
  170.     
  171.     def path_join(self, x, y):
  172.         return os.path.join(x, y)
  173.  
  174.     
  175.     def path_isabs(self, x):
  176.         return os.path.isabs(x)
  177.  
  178.     
  179.     def path_exists(self, x):
  180.         return os.path.exists(x)
  181.  
  182.     
  183.     def path_isdir(self, x):
  184.         return os.path.isdir(x)
  185.  
  186.     
  187.     def path_isfile(self, x):
  188.         return os.path.isfile(x)
  189.  
  190.     
  191.     def path_islink(self, x):
  192.         return os.path.islink(x)
  193.  
  194.     
  195.     def openfile(self, *x):
  196.         return open(*x)
  197.  
  198.     openfile_error = IOError
  199.     
  200.     def listdir(self, x):
  201.         return os.listdir(x)
  202.  
  203.     listdir_error = os.error
  204.  
  205.  
  206. class ModuleLoader(BasicModuleLoader):
  207.     
  208.     def __init__(self, hooks = None, verbose = VERBOSE):
  209.         BasicModuleLoader.__init__(self, verbose)
  210.         if not hooks:
  211.             pass
  212.         self.hooks = Hooks(verbose)
  213.  
  214.     
  215.     def default_path(self):
  216.         return self.hooks.default_path()
  217.  
  218.     
  219.     def modules_dict(self):
  220.         return self.hooks.modules_dict()
  221.  
  222.     
  223.     def get_hooks(self):
  224.         return self.hooks
  225.  
  226.     
  227.     def set_hooks(self, hooks):
  228.         self.hooks = hooks
  229.  
  230.     
  231.     def find_builtin_module(self, name):
  232.         if self.hooks.is_builtin(name):
  233.             return (None, '', ('', '', BUILTIN_MODULE))
  234.         if self.hooks.is_frozen(name):
  235.             return (None, '', ('', '', FROZEN_MODULE))
  236.  
  237.     
  238.     def find_module_in_dir(self, name, dir, allow_packages = 1):
  239.         if dir is None:
  240.             return self.find_builtin_module(name)
  241.         if allow_packages:
  242.             fullname = self.hooks.path_join(dir, name)
  243.             if self.hooks.path_isdir(fullname):
  244.                 stuff = self.find_module_in_dir('__init__', fullname, 0)
  245.                 if stuff:
  246.                     file = stuff[0]
  247.                     if file:
  248.                         file.close()
  249.                     
  250.                     return (None, fullname, ('', '', PKG_DIRECTORY))
  251.             
  252.         
  253.         for info in self.hooks.get_suffixes():
  254.             (suff, mode, type) = info
  255.             fullname = self.hooks.path_join(dir, name + suff)
  256.             
  257.             try:
  258.                 fp = self.hooks.openfile(fullname, mode)
  259.                 return (fp, fullname, info)
  260.             continue
  261.             except self.hooks.openfile_error:
  262.                 continue
  263.             
  264.  
  265.         
  266.  
  267.     
  268.     def load_module(self, name, stuff):
  269.         (file, filename, info) = stuff
  270.         (suff, mode, type) = info
  271.         
  272.         try:
  273.             if type == BUILTIN_MODULE:
  274.                 return self.hooks.init_builtin(name)
  275.             if type == FROZEN_MODULE:
  276.                 return self.hooks.init_frozen(name)
  277.             if type == C_EXTENSION:
  278.                 m = self.hooks.load_dynamic(name, filename, file)
  279.             elif type == PY_SOURCE:
  280.                 m = self.hooks.load_source(name, filename, file)
  281.             elif type == PY_COMPILED:
  282.                 m = self.hooks.load_compiled(name, filename, file)
  283.             elif type == PKG_DIRECTORY:
  284.                 m = self.hooks.load_package(name, filename, file)
  285.             else:
  286.                 raise ImportError, 'Unrecognized module type (%r) for %s' % (type, name)
  287.             m.__file__ = filename
  288.             return m
  289.  
  290.  
  291.  
  292.  
  293. class FancyModuleLoader(ModuleLoader):
  294.     
  295.     def load_module(self, name, stuff):
  296.         (suff, mode, type) = (file, filename)
  297.         realfilename = filename
  298.         path = None
  299.         if type == PKG_DIRECTORY:
  300.             initstuff = self.find_module_in_dir('__init__', filename, 0)
  301.             if not initstuff:
  302.                 raise ImportError, 'No __init__ module in package %s' % name
  303.             initstuff
  304.             (initfile, initfilename, initinfo) = initstuff
  305.             (initsuff, initmode, inittype) = initinfo
  306.             if inittype not in (PY_COMPILED, PY_SOURCE):
  307.                 if initfile:
  308.                     initfile.close()
  309.                 
  310.                 raise ImportError, 'Bad type (%r) for __init__ module in package %s' % (inittype, name)
  311.             inittype not in (PY_COMPILED, PY_SOURCE)
  312.             path = [
  313.                 filename]
  314.             file = initfile
  315.             realfilename = initfilename
  316.             type = inittype
  317.         
  318.         if type == FROZEN_MODULE:
  319.             code = self.hooks.get_frozen_object(name)
  320.         elif type == PY_COMPILED:
  321.             import marshal
  322.             file.seek(8)
  323.             code = marshal.load(file)
  324.         elif type == PY_SOURCE:
  325.             data = file.read()
  326.             code = compile(data, realfilename, 'exec')
  327.         else:
  328.             return ModuleLoader.load_module(self, name, stuff)
  329.         m = (type == FROZEN_MODULE).hooks.add_module(name)
  330.         if path:
  331.             m.__path__ = path
  332.         
  333.         m.__file__ = filename
  334.         
  335.         try:
  336.             exec code in m.__dict__
  337.         except:
  338.             d = self.hooks.modules_dict()
  339.             if name in d:
  340.                 del d[name]
  341.             
  342.             raise 
  343.  
  344.         return m
  345.  
  346.  
  347.  
  348. class BasicModuleImporter(_Verbose):
  349.     
  350.     def __init__(self, loader = None, verbose = VERBOSE):
  351.         _Verbose.__init__(self, verbose)
  352.         if not loader:
  353.             pass
  354.         self.loader = ModuleLoader(None, verbose)
  355.         self.modules = self.loader.modules_dict()
  356.  
  357.     
  358.     def get_loader(self):
  359.         return self.loader
  360.  
  361.     
  362.     def set_loader(self, loader):
  363.         self.loader = loader
  364.  
  365.     
  366.     def get_hooks(self):
  367.         return self.loader.get_hooks()
  368.  
  369.     
  370.     def set_hooks(self, hooks):
  371.         return self.loader.set_hooks(hooks)
  372.  
  373.     
  374.     def import_module(self, name, globals = { }, locals = { }, fromlist = []):
  375.         name = str(name)
  376.         if name in self.modules:
  377.             return self.modules[name]
  378.         stuff = self.loader.find_module(name)
  379.         if not stuff:
  380.             raise ImportError, 'No module named %s' % name
  381.         stuff
  382.         return self.loader.load_module(name, stuff)
  383.  
  384.     
  385.     def reload(self, module, path = None):
  386.         name = str(module.__name__)
  387.         stuff = self.loader.find_module(name, path)
  388.         if not stuff:
  389.             raise ImportError, 'Module %s not found for reload' % name
  390.         stuff
  391.         return self.loader.load_module(name, stuff)
  392.  
  393.     
  394.     def unload(self, module):
  395.         del self.modules[str(module.__name__)]
  396.  
  397.     
  398.     def install(self):
  399.         self.save_import_module = __builtin__.__import__
  400.         self.save_reload = __builtin__.reload
  401.         if not hasattr(__builtin__, 'unload'):
  402.             __builtin__.unload = None
  403.         
  404.         self.save_unload = __builtin__.unload
  405.         __builtin__.__import__ = self.import_module
  406.         __builtin__.reload = self.reload
  407.         __builtin__.unload = self.unload
  408.  
  409.     
  410.     def uninstall(self):
  411.         __builtin__.__import__ = self.save_import_module
  412.         __builtin__.reload = self.save_reload
  413.         __builtin__.unload = self.save_unload
  414.         if not __builtin__.unload:
  415.             del __builtin__.unload
  416.         
  417.  
  418.  
  419.  
  420. class ModuleImporter(BasicModuleImporter):
  421.     
  422.     def import_module(self, name, globals = None, locals = None, fromlist = None):
  423.         parent = self.determine_parent(globals)
  424.         (q, tail) = self.find_head_package(parent, str(name))
  425.         m = self.load_tail(q, tail)
  426.         if not fromlist:
  427.             return q
  428.         if hasattr(m, '__path__'):
  429.             self.ensure_fromlist(m, fromlist)
  430.         
  431.         return m
  432.  
  433.     
  434.     def determine_parent(self, globals):
  435.         if not globals or '__name__' not in globals:
  436.             return None
  437.         pname = globals['__name__']
  438.         if '__path__' in globals:
  439.             parent = self.modules[pname]
  440.             return parent
  441.         if '.' in pname:
  442.             i = pname.rfind('.')
  443.             pname = pname[:i]
  444.             parent = self.modules[pname]
  445.             return parent
  446.  
  447.     
  448.     def find_head_package(self, parent, name):
  449.         if '.' in name:
  450.             i = name.find('.')
  451.             head = name[:i]
  452.             tail = name[i + 1:]
  453.         else:
  454.             head = name
  455.             tail = ''
  456.         if parent:
  457.             qname = '%s.%s' % (parent.__name__, head)
  458.         else:
  459.             qname = head
  460.         q = self.import_it(head, qname, parent)
  461.         if q:
  462.             return (q, tail)
  463.         raise ImportError, 'No module named ' + qname
  464.  
  465.     
  466.     def load_tail(self, q, tail):
  467.         m = q
  468.         while tail:
  469.             i = tail.find('.')
  470.             if i < 0:
  471.                 i = len(tail)
  472.             
  473.             head = tail[:i]
  474.             tail = tail[i + 1:]
  475.             mname = '%s.%s' % (m.__name__, head)
  476.             m = self.import_it(head, mname, m)
  477.             if not m:
  478.                 raise ImportError, 'No module named ' + mname
  479.             m
  480.         return m
  481.  
  482.     
  483.     def ensure_fromlist(self, m, fromlist, recursive = 0):
  484.         for sub in fromlist:
  485.             if sub == '*':
  486.                 if not recursive:
  487.                     
  488.                     try:
  489.                         all = m.__all__
  490.                     except AttributeError:
  491.                         pass
  492.  
  493.                     self.ensure_fromlist(m, all, 1)
  494.                     continue
  495.                 continue
  496.             
  497.             if sub != '*' and not hasattr(m, sub):
  498.                 subname = '%s.%s' % (m.__name__, sub)
  499.                 submod = self.import_it(sub, subname, m)
  500.                 if not submod:
  501.                     raise ImportError, 'No module named ' + subname
  502.                 submod
  503.                 continue
  504.         
  505.  
  506.     
  507.     def import_it(self, partname, fqname, parent, force_load = 0):
  508.         if not partname:
  509.             raise ValueError, 'Empty module name'
  510.         partname
  511.         if not force_load:
  512.             
  513.             try:
  514.                 return self.modules[fqname]
  515.             except KeyError:
  516.                 pass
  517.             except:
  518.                 None<EXCEPTION MATCH>KeyError
  519.             
  520.  
  521.         None<EXCEPTION MATCH>KeyError
  522.         
  523.         try:
  524.             if parent:
  525.                 pass
  526.             path = parent.__path__
  527.         except AttributeError:
  528.             return None
  529.  
  530.         partname = str(partname)
  531.         stuff = self.loader.find_module(partname, path)
  532.         if not stuff:
  533.             return None
  534.         fqname = str(fqname)
  535.         m = self.loader.load_module(fqname, stuff)
  536.         if parent:
  537.             setattr(parent, partname, m)
  538.         
  539.         return m
  540.  
  541.     
  542.     def reload(self, module):
  543.         name = str(module.__name__)
  544.         if '.' not in name:
  545.             return self.import_it(name, name, None, force_load = 1)
  546.         i = name.rfind('.')
  547.         pname = name[:i]
  548.         parent = self.modules[pname]
  549.         return self.import_it(name[i + 1:], name, parent, force_load = 1)
  550.  
  551.  
  552. default_importer = None
  553. current_importer = None
  554.  
  555. def install(importer = None):
  556.     global current_importer
  557.     if not importer and default_importer:
  558.         pass
  559.     current_importer = ModuleImporter()
  560.     current_importer.install()
  561.  
  562.  
  563. def uninstall():
  564.     current_importer.uninstall()
  565.  
  566.