home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / calibre-0.7.26.msi / file_2380 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-10-31  |  5.9 KB  |  202 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import types
  6. import fnmatch
  7. from os.path import basename
  8. from pygments.lexers._mapping import LEXERS
  9. from pygments.plugin import find_plugin_lexers
  10. from pygments.util import ClassNotFound, bytes
  11. __all__ = [
  12.     'get_lexer_by_name',
  13.     'get_lexer_for_filename',
  14.     'find_lexer_class',
  15.     'guess_lexer'] + LEXERS.keys()
  16. _lexer_cache = { }
  17.  
  18. def _load_lexers(module_name):
  19.     mod = __import__(module_name, None, None, [
  20.         '__all__'])
  21.     for lexer_name in mod.__all__:
  22.         cls = getattr(mod, lexer_name)
  23.         _lexer_cache[cls.name] = cls
  24.     
  25.  
  26.  
  27. def get_all_lexers():
  28.     for item in LEXERS.itervalues():
  29.         yield item[1:]
  30.     
  31.     for lexer in find_plugin_lexers():
  32.         yield (lexer.name, lexer.aliases, lexer.filenames, lexer.mimetypes)
  33.     
  34.  
  35.  
  36. def find_lexer_class(name):
  37.     if name in _lexer_cache:
  38.         return _lexer_cache[name]
  39.     for module_name, lname, aliases, _, _ in LEXERS.itervalues():
  40.         if name == lname:
  41.             _load_lexers(module_name)
  42.             return _lexer_cache[name]
  43.     
  44.     for cls in find_plugin_lexers():
  45.         if cls.name == name:
  46.             return cls
  47.     
  48.  
  49.  
  50. def get_lexer_by_name(_alias, **options):
  51.     for module_name, name, aliases, _, _ in LEXERS.itervalues():
  52.         if _alias in aliases:
  53.             if name not in _lexer_cache:
  54.                 _load_lexers(module_name)
  55.             
  56.             return _lexer_cache[name](**options)
  57.     
  58.     for cls in find_plugin_lexers():
  59.         if _alias in cls.aliases:
  60.             return cls(**options)
  61.     
  62.     raise ClassNotFound('no lexer for alias %r found' % _alias)
  63.  
  64.  
  65. def get_lexer_for_filename(_fn, code = None, **options):
  66.     matches = []
  67.     fn = basename(_fn)
  68.     for modname, name, _, filenames, _ in LEXERS.itervalues():
  69.         for filename in filenames:
  70.             if fnmatch.fnmatch(fn, filename):
  71.                 if name not in _lexer_cache:
  72.                     _load_lexers(modname)
  73.                 
  74.                 matches.append(_lexer_cache[name])
  75.                 continue
  76.         
  77.     
  78.     for cls in find_plugin_lexers():
  79.         for filename in cls.filenames:
  80.             if fnmatch.fnmatch(fn, filename):
  81.                 matches.append(cls)
  82.                 continue
  83.         
  84.     
  85.     if sys.version_info > (3,) and isinstance(code, bytes):
  86.         code = code.decode('latin1')
  87.     
  88.     
  89.     def get_rating(cls):
  90.         d = cls.analyse_text(code)
  91.         return d
  92.  
  93.     if code:
  94.         matches.sort(key = get_rating)
  95.     
  96.     if matches:
  97.         return matches[-1](**options)
  98.     raise ClassNotFound('no lexer for filename %r found' % _fn)
  99.  
  100.  
  101. def get_lexer_for_mimetype(_mime, **options):
  102.     for modname, name, _, _, mimetypes in LEXERS.itervalues():
  103.         if _mime in mimetypes:
  104.             if name not in _lexer_cache:
  105.                 _load_lexers(modname)
  106.             
  107.             return _lexer_cache[name](**options)
  108.     
  109.     for cls in find_plugin_lexers():
  110.         if _mime in cls.mimetypes:
  111.             return cls(**options)
  112.     
  113.     raise ClassNotFound('no lexer for mimetype %r found' % _mime)
  114.  
  115.  
  116. def _iter_lexerclasses():
  117.     for module_name, name, _, _, _ in LEXERS.itervalues():
  118.         if name not in _lexer_cache:
  119.             _load_lexers(module_name)
  120.         
  121.         yield _lexer_cache[name]
  122.     
  123.     for lexer in find_plugin_lexers():
  124.         yield lexer
  125.     
  126.  
  127.  
  128. def guess_lexer_for_filename(_fn, _text, **options):
  129.     fn = basename(_fn)
  130.     primary = None
  131.     matching_lexers = set()
  132.     for lexer in _iter_lexerclasses():
  133.         for filename in lexer.filenames:
  134.             if fnmatch.fnmatch(fn, filename):
  135.                 matching_lexers.add(lexer)
  136.                 primary = lexer
  137.                 continue
  138.         
  139.         for filename in lexer.alias_filenames:
  140.             if fnmatch.fnmatch(fn, filename):
  141.                 matching_lexers.add(lexer)
  142.                 continue
  143.         
  144.     
  145.     if not matching_lexers:
  146.         raise ClassNotFound('no lexer for filename %r found' % fn)
  147.     matching_lexers
  148.     if len(matching_lexers) == 1:
  149.         return matching_lexers.pop()(**options)
  150.     result = []
  151.     for lexer in matching_lexers:
  152.         rv = lexer.analyse_text(_text)
  153.         if rv == 1:
  154.             return lexer(**options)
  155.         result.append((rv, lexer))
  156.     
  157.     result.sort()
  158.     if not result[-1][0] and primary is not None:
  159.         return primary(**options)
  160.     return result[-1][1](**options)
  161.  
  162.  
  163. def guess_lexer(_text, **options):
  164.     best_lexer = [
  165.         0,
  166.         None]
  167.     for lexer in _iter_lexerclasses():
  168.         rv = lexer.analyse_text(_text)
  169.         if rv == 1:
  170.             return lexer(**options)
  171.         if rv > best_lexer[0]:
  172.             best_lexer[:] = (rv, lexer)
  173.             continue
  174.         rv == 1
  175.     
  176.     if not best_lexer[0] or best_lexer[1] is None:
  177.         raise ClassNotFound('no lexer matching the text found')
  178.     best_lexer[1] is None
  179.     return best_lexer[1](**options)
  180.  
  181.  
  182. class _automodule(types.ModuleType):
  183.     
  184.     def __getattr__(self, name):
  185.         info = LEXERS.get(name)
  186.         if info:
  187.             _load_lexers(info[0])
  188.             cls = _lexer_cache[info[1]]
  189.             setattr(self, name, cls)
  190.             return cls
  191.         raise AttributeError(name)
  192.  
  193.  
  194. oldmod = sys.modules['pygments.lexers']
  195. newmod = _automodule('pygments.lexers')
  196. newmod.__dict__.update(oldmod.__dict__)
  197. sys.modules['pygments.lexers'] = newmod
  198. del newmod.newmod
  199. del newmod.oldmod
  200. del newmod.sys
  201. del newmod.types
  202.