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