home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2805 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  11.3 KB  |  359 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. whitespace = ' \t\n\r\x0b\x0c'
  5. lowercase = 'abcdefghijklmnopqrstuvwxyz'
  6. uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  7. letters = lowercase + uppercase
  8. ascii_lowercase = lowercase
  9. ascii_uppercase = uppercase
  10. ascii_letters = ascii_lowercase + ascii_uppercase
  11. digits = '0123456789'
  12. hexdigits = digits + 'abcdef' + 'ABCDEF'
  13. octdigits = '01234567'
  14. punctuation = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
  15. printable = digits + letters + punctuation + whitespace
  16. l = map(chr, xrange(256))
  17. _idmap = str('').join(l)
  18. del l
  19.  
  20. def capwords(s, sep = None):
  21.     if not sep:
  22.         pass
  23.     return ' '.join((lambda .0: for x in .0:
  24. x.capitalize())(s.split(sep)))
  25.  
  26. _idmapL = None
  27.  
  28. def maketrans(fromstr, tostr):
  29.     global _idmapL
  30.     if len(fromstr) != len(tostr):
  31.         raise ValueError, 'maketrans arguments must have same length'
  32.     len(fromstr) != len(tostr)
  33.     if not _idmapL:
  34.         _idmapL = list(_idmap)
  35.     
  36.     L = _idmapL[:]
  37.     fromstr = map(ord, fromstr)
  38.     for i in range(len(fromstr)):
  39.         L[fromstr[i]] = tostr[i]
  40.     
  41.     return ''.join(L)
  42.  
  43. import re as _re
  44.  
  45. class _multimap:
  46.     
  47.     def __init__(self, primary, secondary):
  48.         self._primary = primary
  49.         self._secondary = secondary
  50.  
  51.     
  52.     def __getitem__(self, key):
  53.         
  54.         try:
  55.             return self._primary[key]
  56.         except KeyError:
  57.             return self._secondary[key]
  58.  
  59.  
  60.  
  61.  
  62. class _TemplateMetaclass(type):
  63.     pattern = '\n    %(delim)s(?:\n      (?P<escaped>%(delim)s) |   # Escape sequence of two delimiters\n      (?P<named>%(id)s)      |   # delimiter and a Python identifier\n      {(?P<braced>%(id)s)}   |   # delimiter and a braced identifier\n      (?P<invalid>)              # Other ill-formed delimiter exprs\n    )\n    '
  64.     
  65.     def __init__(cls, name, bases, dct):
  66.         super(_TemplateMetaclass, cls).__init__(name, bases, dct)
  67.         if 'pattern' in dct:
  68.             pattern = cls.pattern
  69.         else:
  70.             pattern = _TemplateMetaclass.pattern % {
  71.                 'delim': _re.escape(cls.delimiter),
  72.                 'id': cls.idpattern }
  73.         cls.pattern = _re.compile(pattern, _re.IGNORECASE | _re.VERBOSE)
  74.  
  75.  
  76.  
  77. class Template:
  78.     __metaclass__ = _TemplateMetaclass
  79.     delimiter = '$'
  80.     idpattern = '[_a-z][_a-z0-9]*'
  81.     
  82.     def __init__(self, template):
  83.         self.template = template
  84.  
  85.     
  86.     def _invalid(self, mo):
  87.         i = mo.start('invalid')
  88.         lines = self.template[:i].splitlines(True)
  89.         if not lines:
  90.             colno = 1
  91.             lineno = 1
  92.         else:
  93.             colno = i - len(''.join(lines[:-1]))
  94.             lineno = len(lines)
  95.         raise ValueError('Invalid placeholder in string: line %d, col %d' % (lineno, colno))
  96.  
  97.     
  98.     def substitute(self, *args, **kws):
  99.         if len(args) > 1:
  100.             raise TypeError('Too many positional arguments')
  101.         len(args) > 1
  102.         if not args:
  103.             mapping = kws
  104.         elif kws:
  105.             mapping = _multimap(kws, args[0])
  106.         else:
  107.             mapping = args[0]
  108.         
  109.         def convert(mo):
  110.             if not mo.group('named'):
  111.                 pass
  112.             named = mo.group('braced')
  113.             if named is not None:
  114.                 val = mapping[named]
  115.                 return '%s' % (val,)
  116.             if mo.group('escaped') is not None:
  117.                 return self.delimiter
  118.             raise ValueError('Unrecognized named group in pattern', self.pattern)
  119.  
  120.         return self.pattern.sub(convert, self.template)
  121.  
  122.     
  123.     def safe_substitute(self, *args, **kws):
  124.         if len(args) > 1:
  125.             raise TypeError('Too many positional arguments')
  126.         len(args) > 1
  127.         if not args:
  128.             mapping = kws
  129.         elif kws:
  130.             mapping = _multimap(kws, args[0])
  131.         else:
  132.             mapping = args[0]
  133.         
  134.         def convert(mo):
  135.             named = mo.group('named')
  136.             if named is not None:
  137.                 
  138.                 try:
  139.                     return '%s' % (mapping[named],)
  140.                 except KeyError:
  141.                     return self.delimiter + named
  142.                 
  143.  
  144.             None<EXCEPTION MATCH>KeyError
  145.             braced = mo.group('braced')
  146.             if braced is not None:
  147.                 
  148.                 try:
  149.                     return '%s' % (mapping[braced],)
  150.                 except KeyError:
  151.                     return self.delimiter + '{' + braced + '}'
  152.                 
  153.  
  154.             None<EXCEPTION MATCH>KeyError
  155.             if mo.group('escaped') is not None:
  156.                 return self.delimiter
  157.             if mo.group('invalid') is not None:
  158.                 return self.delimiter
  159.             raise ValueError('Unrecognized named group in pattern', self.pattern)
  160.  
  161.         return self.pattern.sub(convert, self.template)
  162.  
  163.  
  164. index_error = ValueError
  165. atoi_error = ValueError
  166. atof_error = ValueError
  167. atol_error = ValueError
  168.  
  169. def lower(s):
  170.     return s.lower()
  171.  
  172.  
  173. def upper(s):
  174.     return s.upper()
  175.  
  176.  
  177. def swapcase(s):
  178.     return s.swapcase()
  179.  
  180.  
  181. def strip(s, chars = None):
  182.     return s.strip(chars)
  183.  
  184.  
  185. def lstrip(s, chars = None):
  186.     return s.lstrip(chars)
  187.  
  188.  
  189. def rstrip(s, chars = None):
  190.     return s.rstrip(chars)
  191.  
  192.  
  193. def split(s, sep = None, maxsplit = -1):
  194.     return s.split(sep, maxsplit)
  195.  
  196. splitfields = split
  197.  
  198. def rsplit(s, sep = None, maxsplit = -1):
  199.     return s.rsplit(sep, maxsplit)
  200.  
  201.  
  202. def join(words, sep = ' '):
  203.     return sep.join(words)
  204.  
  205. joinfields = join
  206.  
  207. def index(s, *args):
  208.     return s.index(*args)
  209.  
  210.  
  211. def rindex(s, *args):
  212.     return s.rindex(*args)
  213.  
  214.  
  215. def count(s, *args):
  216.     return s.count(*args)
  217.  
  218.  
  219. def find(s, *args):
  220.     return s.find(*args)
  221.  
  222.  
  223. def rfind(s, *args):
  224.     return s.rfind(*args)
  225.  
  226. _float = float
  227. _int = int
  228. _long = long
  229.  
  230. def atof(s):
  231.     return _float(s)
  232.  
  233.  
  234. def atoi(s, base = 10):
  235.     return _int(s, base)
  236.  
  237.  
  238. def atol(s, base = 10):
  239.     return _long(s, base)
  240.  
  241.  
  242. def ljust(s, width, *args):
  243.     return s.ljust(width, *args)
  244.  
  245.  
  246. def rjust(s, width, *args):
  247.     return s.rjust(width, *args)
  248.  
  249.  
  250. def center(s, width, *args):
  251.     return s.center(width, *args)
  252.  
  253.  
  254. def zfill(x, width):
  255.     if not isinstance(x, basestring):
  256.         x = repr(x)
  257.     
  258.     return x.zfill(width)
  259.  
  260.  
  261. def expandtabs(s, tabsize = 8):
  262.     return s.expandtabs(tabsize)
  263.  
  264.  
  265. def translate(s, table, deletions = ''):
  266.     if deletions or table is None:
  267.         return s.translate(table, deletions)
  268.     return s.translate(table + s[:0])
  269.  
  270.  
  271. def capitalize(s):
  272.     return s.capitalize()
  273.  
  274.  
  275. def replace(s, old, new, maxsplit = -1):
  276.     return s.replace(old, new, maxsplit)
  277.  
  278.  
  279. try:
  280.     from strop import maketrans, lowercase, uppercase, whitespace
  281.     letters = lowercase + uppercase
  282. except ImportError:
  283.     pass
  284.  
  285.  
  286. class Formatter(object):
  287.     
  288.     def format(self, format_string, *args, **kwargs):
  289.         return self.vformat(format_string, args, kwargs)
  290.  
  291.     
  292.     def vformat(self, format_string, args, kwargs):
  293.         used_args = set()
  294.         result = self._vformat(format_string, args, kwargs, used_args, 2)
  295.         self.check_unused_args(used_args, args, kwargs)
  296.         return result
  297.  
  298.     
  299.     def _vformat(self, format_string, args, kwargs, used_args, recursion_depth):
  300.         if recursion_depth < 0:
  301.             raise ValueError('Max string recursion exceeded')
  302.         recursion_depth < 0
  303.         result = []
  304.         for literal_text, field_name, format_spec, conversion in self.parse(format_string):
  305.             if literal_text:
  306.                 result.append(literal_text)
  307.             
  308.             if field_name is not None:
  309.                 (obj, arg_used) = self.get_field(field_name, args, kwargs)
  310.                 used_args.add(arg_used)
  311.                 obj = self.convert_field(obj, conversion)
  312.                 format_spec = self._vformat(format_spec, args, kwargs, used_args, recursion_depth - 1)
  313.                 result.append(self.format_field(obj, format_spec))
  314.                 continue
  315.         
  316.         return ''.join(result)
  317.  
  318.     
  319.     def get_value(self, key, args, kwargs):
  320.         if isinstance(key, (int, long)):
  321.             return args[key]
  322.         return kwargs[key]
  323.  
  324.     
  325.     def check_unused_args(self, used_args, args, kwargs):
  326.         pass
  327.  
  328.     
  329.     def format_field(self, value, format_spec):
  330.         return format(value, format_spec)
  331.  
  332.     
  333.     def convert_field(self, value, conversion):
  334.         if conversion == 'r':
  335.             return repr(value)
  336.         if conversion == 's':
  337.             return str(value)
  338.         if conversion is None:
  339.             return value
  340.         raise ValueError('Unknown converion specifier {0!s}'.format(conversion))
  341.  
  342.     
  343.     def parse(self, format_string):
  344.         return format_string._formatter_parser()
  345.  
  346.     
  347.     def get_field(self, field_name, args, kwargs):
  348.         (first, rest) = field_name._formatter_field_name_split()
  349.         obj = self.get_value(first, args, kwargs)
  350.         for is_attr, i in rest:
  351.             if is_attr:
  352.                 obj = getattr(obj, i)
  353.                 continue
  354.             obj = obj[i]
  355.         
  356.         return (obj, first)
  357.  
  358.  
  359.