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