home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2424 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  5.1 KB  |  175 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from __future__ import generators
  5. import sys
  6. import imp
  7. import marshal
  8. from imp import PKG_DIRECTORY, PY_COMPILED, PY_SOURCE, PY_FROZEN
  9. from distutils.version import StrictVersion, LooseVersion
  10. __all__ = [
  11.     'Require',
  12.     'find_module',
  13.     'get_module_constant',
  14.     'extract_constant']
  15.  
  16. class Require:
  17.     
  18.     def __init__(self, name, requested_version, module, homepage = '', attribute = None, format = None):
  19.         if format is None and requested_version is not None:
  20.             format = StrictVersion
  21.         
  22.         if format is not None:
  23.             requested_version = format(requested_version)
  24.             if attribute is None:
  25.                 attribute = '__version__'
  26.             
  27.         
  28.         self.__dict__.update(locals())
  29.         del self.self
  30.  
  31.     
  32.     def full_name(self):
  33.         if self.requested_version is not None:
  34.             return '%s-%s' % (self.name, self.requested_version)
  35.         return self.name
  36.  
  37.     
  38.     def version_ok(self, version):
  39.         if self.attribute is None and self.format is None and str(version) != 'unknown':
  40.             pass
  41.         return version >= self.requested_version
  42.  
  43.     
  44.     def get_version(self, paths = None, default = 'unknown'):
  45.         if self.attribute is None:
  46.             
  47.             try:
  48.                 (f, p, i) = find_module(self.module, paths)
  49.                 if f:
  50.                     f.close()
  51.                 
  52.                 return default
  53.             except ImportError:
  54.                 return None
  55.             
  56.  
  57.         None<EXCEPTION MATCH>ImportError
  58.         v = get_module_constant(self.module, self.attribute, default, paths)
  59.         if v is not None and v is not default and self.format is not None:
  60.             return self.format(v)
  61.         return v
  62.  
  63.     
  64.     def is_present(self, paths = None):
  65.         return self.get_version(paths) is not None
  66.  
  67.     
  68.     def is_current(self, paths = None):
  69.         version = self.get_version(paths)
  70.         if version is None:
  71.             return False
  72.         return self.version_ok(version)
  73.  
  74.  
  75.  
  76. def _iter_code(code):
  77.     array = array
  78.     import array
  79.     HAVE_ARGUMENT = HAVE_ARGUMENT
  80.     EXTENDED_ARG = EXTENDED_ARG
  81.     import dis
  82.     bytes = array('b', code.co_code)
  83.     eof = len(code.co_code)
  84.     ptr = 0
  85.     extended_arg = 0
  86.     while ptr < eof:
  87.         op = bytes[ptr]
  88.         if op >= HAVE_ARGUMENT:
  89.             arg = bytes[ptr + 1] + bytes[ptr + 2] * 256 + extended_arg
  90.             ptr += 3
  91.             if op == EXTENDED_ARG:
  92.                 extended_arg = arg * 0x10000L
  93.                 continue
  94.             
  95.         else:
  96.             arg = None
  97.             ptr += 1
  98.         yield (op, arg)
  99.  
  100.  
  101. def find_module(module, paths = None):
  102.     parts = module.split('.')
  103.     while parts:
  104.         part = parts.pop(0)
  105.         (suffix, mode, kind) = (f, path)
  106.         if kind == PKG_DIRECTORY:
  107.             if not parts:
  108.                 pass
  109.             parts = [
  110.                 '__init__']
  111.             paths = [
  112.                 path]
  113.             continue
  114.         info = imp.find_module(part, paths)
  115.         if parts:
  116.             raise ImportError("Can't find %r in %s" % (parts, module))
  117.         parts
  118.         continue
  119.         imp.find_module(part, paths)
  120.     return info
  121.  
  122.  
  123. def get_module_constant(module, symbol, default = -1, paths = None):
  124.     
  125.     try:
  126.         (suffix, mode, kind) = (f, path)
  127.     except ImportError:
  128.         return None
  129.  
  130.     
  131.     try:
  132.         if kind == PY_COMPILED:
  133.             f.read(8)
  134.             code = marshal.load(f)
  135.         elif kind == PY_FROZEN:
  136.             code = imp.get_frozen_object(module)
  137.         elif kind == PY_SOURCE:
  138.             code = compile(f.read(), path, 'exec')
  139.         elif module not in sys.modules:
  140.             imp.load_module(module, f, path, (suffix, mode, kind))
  141.         
  142.         return getattr(sys.modules[module], symbol, None)
  143.     finally:
  144.         if f:
  145.             f.close()
  146.         
  147.  
  148.     return extract_constant(code, symbol, default)
  149.  
  150.  
  151. def extract_constant(code, symbol, default = -1):
  152.     if symbol not in code.co_names:
  153.         return None
  154.     name_idx = list(code.co_names).index(symbol)
  155.     STORE_NAME = 90
  156.     STORE_GLOBAL = 97
  157.     LOAD_CONST = 100
  158.     const = default
  159.     for op, arg in _iter_code(code):
  160.         if op == LOAD_CONST:
  161.             const = code.co_consts[arg]
  162.             continue
  163.         symbol not in code.co_names
  164.         if arg == name_idx:
  165.             if op == STORE_NAME or op == STORE_GLOBAL:
  166.                 return const
  167.             const = default
  168.  
  169. if sys.platform.startswith('java') or sys.platform == 'cli':
  170.     del extract_constant
  171.     del get_module_constant
  172.     __all__.remove('extract_constant')
  173.     __all__.remove('get_module_constant')
  174.  
  175.