+++ /dev/null
-"""A collection of string operations (most are no longer used).\r
-\r
-Warning: most of the code you see here isn't normally used nowadays.\r
-Beginning with Python 1.6, many of these functions are implemented as\r
-methods on the standard string object. They used to be implemented by\r
-a built-in module called strop, but strop is now obsolete itself.\r
-\r
-Public module variables:\r
-\r
-whitespace -- a string containing all characters considered whitespace\r
-lowercase -- a string containing all characters considered lowercase letters\r
-uppercase -- a string containing all characters considered uppercase letters\r
-letters -- a string containing all characters considered letters\r
-digits -- a string containing all characters considered decimal digits\r
-hexdigits -- a string containing all characters considered hexadecimal digits\r
-octdigits -- a string containing all characters considered octal digits\r
-punctuation -- a string containing all characters considered punctuation\r
-printable -- a string containing all characters considered printable\r
-\r
-"""\r
-\r
-# Some strings for ctype-style character classification\r
-whitespace = ' \t\n\r\v\f'\r
-lowercase = 'abcdefghijklmnopqrstuvwxyz'\r
-uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\r
-letters = lowercase + uppercase\r
-ascii_lowercase = lowercase\r
-ascii_uppercase = uppercase\r
-ascii_letters = ascii_lowercase + ascii_uppercase\r
-digits = '0123456789'\r
-hexdigits = digits + 'abcdef' + 'ABCDEF'\r
-octdigits = '01234567'\r
-punctuation = """!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""\r
-printable = digits + letters + punctuation + whitespace\r
-\r
-# Case conversion helpers\r
-# Use str to convert Unicode literal in case of -U\r
-l = map(chr, xrange(256))\r
-_idmap = str('').join(l)\r
-del l\r
-\r
-# Functions which aren't available as string methods.\r
-\r
-# Capitalize the words in a string, e.g. " aBc dEf " -> "Abc Def".\r
-def capwords(s, sep=None):\r
- """capwords(s [,sep]) -> string\r
-\r
- Split the argument into words using split, capitalize each\r
- word using capitalize, and join the capitalized words using\r
- join. If the optional second argument sep is absent or None,\r
- runs of whitespace characters are replaced by a single space\r
- and leading and trailing whitespace are removed, otherwise\r
- sep is used to split and join the words.\r
-\r
- """\r
- return (sep or ' ').join(x.capitalize() for x in s.split(sep))\r
-\r
-\r
-# Construct a translation string\r
-_idmapL = None\r
-def maketrans(fromstr, tostr):\r
- """maketrans(frm, to) -> string\r
-\r
- Return a translation table (a string of 256 bytes long)\r
- suitable for use in string.translate. The strings frm and to\r
- must be of the same length.\r
-\r
- """\r
- if len(fromstr) != len(tostr):\r
- raise ValueError, "maketrans arguments must have same length"\r
- global _idmapL\r
- if not _idmapL:\r
- _idmapL = list(_idmap)\r
- L = _idmapL[:]\r
- fromstr = map(ord, fromstr)\r
- for i in range(len(fromstr)):\r
- L[fromstr[i]] = tostr[i]\r
- return ''.join(L)\r
-\r
-\r
-\r
-####################################################################\r
-import re as _re\r
-\r
-class _multimap:\r
- """Helper class for combining multiple mappings.\r
-\r
- Used by .{safe_,}substitute() to combine the mapping and keyword\r
- arguments.\r
- """\r
- def __init__(self, primary, secondary):\r
- self._primary = primary\r
- self._secondary = secondary\r
-\r
- def __getitem__(self, key):\r
- try:\r
- return self._primary[key]\r
- except KeyError:\r
- return self._secondary[key]\r
-\r
-\r
-class _TemplateMetaclass(type):\r
- pattern = r"""\r
- %(delim)s(?:\r
- (?P<escaped>%(delim)s) | # Escape sequence of two delimiters\r
- (?P<named>%(id)s) | # delimiter and a Python identifier\r
- {(?P<braced>%(id)s)} | # delimiter and a braced identifier\r
- (?P<invalid>) # Other ill-formed delimiter exprs\r
- )\r
- """\r
-\r
- def __init__(cls, name, bases, dct):\r
- super(_TemplateMetaclass, cls).__init__(name, bases, dct)\r
- if 'pattern' in dct:\r
- pattern = cls.pattern\r
- else:\r
- pattern = _TemplateMetaclass.pattern % {\r
- 'delim' : _re.escape(cls.delimiter),\r
- 'id' : cls.idpattern,\r
- }\r
- cls.pattern = _re.compile(pattern, _re.IGNORECASE | _re.VERBOSE)\r
-\r
-\r
-class Template:\r
- """A string class for supporting $-substitutions."""\r
- __metaclass__ = _TemplateMetaclass\r
-\r
- delimiter = '$'\r
- idpattern = r'[_a-z][_a-z0-9]*'\r
-\r
- def __init__(self, template):\r
- self.template = template\r
-\r
- # Search for $$, $identifier, ${identifier}, and any bare $'s\r
-\r
- def _invalid(self, mo):\r
- i = mo.start('invalid')\r
- lines = self.template[:i].splitlines(True)\r
- if not lines:\r
- colno = 1\r
- lineno = 1\r
- else:\r
- colno = i - len(''.join(lines[:-1]))\r
- lineno = len(lines)\r
- raise ValueError('Invalid placeholder in string: line %d, col %d' %\r
- (lineno, colno))\r
-\r
- def substitute(self, *args, **kws):\r
- if len(args) > 1:\r
- raise TypeError('Too many positional arguments')\r
- if not args:\r
- mapping = kws\r
- elif kws:\r
- mapping = _multimap(kws, args[0])\r
- else:\r
- mapping = args[0]\r
- # Helper function for .sub()\r
- def convert(mo):\r
- # Check the most common path first.\r
- named = mo.group('named') or mo.group('braced')\r
- if named is not None:\r
- val = mapping[named]\r
- # We use this idiom instead of str() because the latter will\r
- # fail if val is a Unicode containing non-ASCII characters.\r
- return '%s' % (val,)\r
- if mo.group('escaped') is not None:\r
- return self.delimiter\r
- if mo.group('invalid') is not None:\r
- self._invalid(mo)\r
- raise ValueError('Unrecognized named group in pattern',\r
- self.pattern)\r
- return self.pattern.sub(convert, self.template)\r
-\r
- def safe_substitute(self, *args, **kws):\r
- if len(args) > 1:\r
- raise TypeError('Too many positional arguments')\r
- if not args:\r
- mapping = kws\r
- elif kws:\r
- mapping = _multimap(kws, args[0])\r
- else:\r
- mapping = args[0]\r
- # Helper function for .sub()\r
- def convert(mo):\r
- named = mo.group('named')\r
- if named is not None:\r
- try:\r
- # We use this idiom instead of str() because the latter\r
- # will fail if val is a Unicode containing non-ASCII\r
- return '%s' % (mapping[named],)\r
- except KeyError:\r
- return self.delimiter + named\r
- braced = mo.group('braced')\r
- if braced is not None:\r
- try:\r
- return '%s' % (mapping[braced],)\r
- except KeyError:\r
- return self.delimiter + '{' + braced + '}'\r
- if mo.group('escaped') is not None:\r
- return self.delimiter\r
- if mo.group('invalid') is not None:\r
- return self.delimiter\r
- raise ValueError('Unrecognized named group in pattern',\r
- self.pattern)\r
- return self.pattern.sub(convert, self.template)\r
-\r
-\r
-\r
-####################################################################\r
-# NOTE: Everything below here is deprecated. Use string methods instead.\r
-# This stuff will go away in Python 3.0.\r
-\r
-# Backward compatible names for exceptions\r
-index_error = ValueError\r
-atoi_error = ValueError\r
-atof_error = ValueError\r
-atol_error = ValueError\r
-\r
-# convert UPPER CASE letters to lower case\r
-def lower(s):\r
- """lower(s) -> string\r
-\r
- Return a copy of the string s converted to lowercase.\r
-\r
- """\r
- return s.lower()\r
-\r
-# Convert lower case letters to UPPER CASE\r
-def upper(s):\r
- """upper(s) -> string\r
-\r
- Return a copy of the string s converted to uppercase.\r
-\r
- """\r
- return s.upper()\r
-\r
-# Swap lower case letters and UPPER CASE\r
-def swapcase(s):\r
- """swapcase(s) -> string\r
-\r
- Return a copy of the string s with upper case characters\r
- converted to lowercase and vice versa.\r
-\r
- """\r
- return s.swapcase()\r
-\r
-# Strip leading and trailing tabs and spaces\r
-def strip(s, chars=None):\r
- """strip(s [,chars]) -> string\r
-\r
- Return a copy of the string s with leading and trailing\r
- whitespace removed.\r
- If chars is given and not None, remove characters in chars instead.\r
- If chars is unicode, S will be converted to unicode before stripping.\r
-\r
- """\r
- return s.strip(chars)\r
-\r
-# Strip leading tabs and spaces\r
-def lstrip(s, chars=None):\r
- """lstrip(s [,chars]) -> string\r
-\r
- Return a copy of the string s with leading whitespace removed.\r
- If chars is given and not None, remove characters in chars instead.\r
-\r
- """\r
- return s.lstrip(chars)\r
-\r
-# Strip trailing tabs and spaces\r
-def rstrip(s, chars=None):\r
- """rstrip(s [,chars]) -> string\r
-\r
- Return a copy of the string s with trailing whitespace removed.\r
- If chars is given and not None, remove characters in chars instead.\r
-\r
- """\r
- return s.rstrip(chars)\r
-\r
-\r
-# Split a string into a list of space/tab-separated words\r
-def split(s, sep=None, maxsplit=-1):\r
- """split(s [,sep [,maxsplit]]) -> list of strings\r
-\r
- Return a list of the words in the string s, using sep as the\r
- delimiter string. If maxsplit is given, splits at no more than\r
- maxsplit places (resulting in at most maxsplit+1 words). If sep\r
- is not specified or is None, any whitespace string is a separator.\r
-\r
- (split and splitfields are synonymous)\r
-\r
- """\r
- return s.split(sep, maxsplit)\r
-splitfields = split\r
-\r
-# Split a string into a list of space/tab-separated words\r
-def rsplit(s, sep=None, maxsplit=-1):\r
- """rsplit(s [,sep [,maxsplit]]) -> list of strings\r
-\r
- Return a list of the words in the string s, using sep as the\r
- delimiter string, starting at the end of the string and working\r
- to the front. If maxsplit is given, at most maxsplit splits are\r
- done. If sep is not specified or is None, any whitespace string\r
- is a separator.\r
- """\r
- return s.rsplit(sep, maxsplit)\r
-\r
-# Join fields with optional separator\r
-def join(words, sep = ' '):\r
- """join(list [,sep]) -> string\r
-\r
- Return a string composed of the words in list, with\r
- intervening occurrences of sep. The default separator is a\r
- single space.\r
-\r
- (joinfields and join are synonymous)\r
-\r
- """\r
- return sep.join(words)\r
-joinfields = join\r
-\r
-# Find substring, raise exception if not found\r
-def index(s, *args):\r
- """index(s, sub [,start [,end]]) -> int\r
-\r
- Like find but raises ValueError when the substring is not found.\r
-\r
- """\r
- return s.index(*args)\r
-\r
-# Find last substring, raise exception if not found\r
-def rindex(s, *args):\r
- """rindex(s, sub [,start [,end]]) -> int\r
-\r
- Like rfind but raises ValueError when the substring is not found.\r
-\r
- """\r
- return s.rindex(*args)\r
-\r
-# Count non-overlapping occurrences of substring\r
-def count(s, *args):\r
- """count(s, sub[, start[,end]]) -> int\r
-\r
- Return the number of occurrences of substring sub in string\r
- s[start:end]. Optional arguments start and end are\r
- interpreted as in slice notation.\r
-\r
- """\r
- return s.count(*args)\r
-\r
-# Find substring, return -1 if not found\r
-def find(s, *args):\r
- """find(s, sub [,start [,end]]) -> in\r
-\r
- Return the lowest index in s where substring sub is found,\r
- such that sub is contained within s[start,end]. Optional\r
- arguments start and end are interpreted as in slice notation.\r
-\r
- Return -1 on failure.\r
-\r
- """\r
- return s.find(*args)\r
-\r
-# Find last substring, return -1 if not found\r
-def rfind(s, *args):\r
- """rfind(s, sub [,start [,end]]) -> int\r
-\r
- Return the highest index in s where substring sub is found,\r
- such that sub is contained within s[start,end]. Optional\r
- arguments start and end are interpreted as in slice notation.\r
-\r
- Return -1 on failure.\r
-\r
- """\r
- return s.rfind(*args)\r
-\r
-# for a bit of speed\r
-_float = float\r
-_int = int\r
-_long = long\r
-\r
-# Convert string to float\r
-def atof(s):\r
- """atof(s) -> float\r
-\r
- Return the floating point number represented by the string s.\r
-\r
- """\r
- return _float(s)\r
-\r
-\r
-# Convert string to integer\r
-def atoi(s , base=10):\r
- """atoi(s [,base]) -> int\r
-\r
- Return the integer represented by the string s in the given\r
- base, which defaults to 10. The string s must consist of one\r
- or more digits, possibly preceded by a sign. If base is 0, it\r
- is chosen from the leading characters of s, 0 for octal, 0x or\r
- 0X for hexadecimal. If base is 16, a preceding 0x or 0X is\r
- accepted.\r
-\r
- """\r
- return _int(s, base)\r
-\r
-\r
-# Convert string to long integer\r
-def atol(s, base=10):\r
- """atol(s [,base]) -> long\r
-\r
- Return the long integer represented by the string s in the\r
- given base, which defaults to 10. The string s must consist\r
- of one or more digits, possibly preceded by a sign. If base\r
- is 0, it is chosen from the leading characters of s, 0 for\r
- octal, 0x or 0X for hexadecimal. If base is 16, a preceding\r
- 0x or 0X is accepted. A trailing L or l is not accepted,\r
- unless base is 0.\r
-\r
- """\r
- return _long(s, base)\r
-\r
-\r
-# Left-justify a string\r
-def ljust(s, width, *args):\r
- """ljust(s, width[, fillchar]) -> string\r
-\r
- Return a left-justified version of s, in a field of the\r
- specified width, padded with spaces as needed. The string is\r
- never truncated. If specified the fillchar is used instead of spaces.\r
-\r
- """\r
- return s.ljust(width, *args)\r
-\r
-# Right-justify a string\r
-def rjust(s, width, *args):\r
- """rjust(s, width[, fillchar]) -> string\r
-\r
- Return a right-justified version of s, in a field of the\r
- specified width, padded with spaces as needed. The string is\r
- never truncated. If specified the fillchar is used instead of spaces.\r
-\r
- """\r
- return s.rjust(width, *args)\r
-\r
-# Center a string\r
-def center(s, width, *args):\r
- """center(s, width[, fillchar]) -> string\r
-\r
- Return a center version of s, in a field of the specified\r
- width. padded with spaces as needed. The string is never\r
- truncated. If specified the fillchar is used instead of spaces.\r
-\r
- """\r
- return s.center(width, *args)\r
-\r
-# Zero-fill a number, e.g., (12, 3) --> '012' and (-3, 3) --> '-03'\r
-# Decadent feature: the argument may be a string or a number\r
-# (Use of this is deprecated; it should be a string as with ljust c.s.)\r
-def zfill(x, width):\r
- """zfill(x, width) -> string\r
-\r
- Pad a numeric string x with zeros on the left, to fill a field\r
- of the specified width. The string x is never truncated.\r
-\r
- """\r
- if not isinstance(x, basestring):\r
- x = repr(x)\r
- return x.zfill(width)\r
-\r
-# Expand tabs in a string.\r
-# Doesn't take non-printing chars into account, but does understand \n.\r
-def expandtabs(s, tabsize=8):\r
- """expandtabs(s [,tabsize]) -> string\r
-\r
- Return a copy of the string s with all tab characters replaced\r
- by the appropriate number of spaces, depending on the current\r
- column, and the tabsize (default 8).\r
-\r
- """\r
- return s.expandtabs(tabsize)\r
-\r
-# Character translation through look-up table.\r
-def translate(s, table, deletions=""):\r
- """translate(s,table [,deletions]) -> string\r
-\r
- Return a copy of the string s, where all characters occurring\r
- in the optional argument deletions are removed, and the\r
- remaining characters have been mapped through the given\r
- translation table, which must be a string of length 256. The\r
- deletions argument is not allowed for Unicode strings.\r
-\r
- """\r
- if deletions or table is None:\r
- return s.translate(table, deletions)\r
- else:\r
- # Add s[:0] so that if s is Unicode and table is an 8-bit string,\r
- # table is converted to Unicode. This means that table *cannot*\r
- # be a dictionary -- for that feature, use u.translate() directly.\r
- return s.translate(table + s[:0])\r
-\r
-# Capitalize a string, e.g. "aBc dEf" -> "Abc def".\r
-def capitalize(s):\r
- """capitalize(s) -> string\r
-\r
- Return a copy of the string s with only its first character\r
- capitalized.\r
-\r
- """\r
- return s.capitalize()\r
-\r
-# Substring replacement (global)\r
-def replace(s, old, new, maxreplace=-1):\r
- """replace (str, old, new[, maxreplace]) -> string\r
-\r
- Return a copy of string str with all occurrences of substring\r
- old replaced by new. If the optional argument maxreplace is\r
- given, only the first maxreplace occurrences are replaced.\r
-\r
- """\r
- return s.replace(old, new, maxreplace)\r
-\r
-\r
-# Try importing optional built-in module "strop" -- if it exists,\r
-# it redefines some string operations that are 100-1000 times faster.\r
-# It also defines values for whitespace, lowercase and uppercase\r
-# that match <ctype.h>'s definitions.\r
-\r
-try:\r
- from strop import maketrans, lowercase, uppercase, whitespace\r
- letters = lowercase + uppercase\r
-except ImportError:\r
- pass # Use the original versions\r
-\r
-########################################################################\r
-# the Formatter class\r
-# see PEP 3101 for details and purpose of this class\r
-\r
-# The hard parts are reused from the C implementation. They're exposed as "_"\r
-# prefixed methods of str and unicode.\r
-\r
-# The overall parser is implemented in str._formatter_parser.\r
-# The field name parser is implemented in str._formatter_field_name_split\r
-\r
-class Formatter(object):\r
- def format(self, format_string, *args, **kwargs):\r
- return self.vformat(format_string, args, kwargs)\r
-\r
- def vformat(self, format_string, args, kwargs):\r
- used_args = set()\r
- result = self._vformat(format_string, args, kwargs, used_args, 2)\r
- self.check_unused_args(used_args, args, kwargs)\r
- return result\r
-\r
- def _vformat(self, format_string, args, kwargs, used_args, recursion_depth):\r
- if recursion_depth < 0:\r
- raise ValueError('Max string recursion exceeded')\r
- result = []\r
- for literal_text, field_name, format_spec, conversion in \\r
- self.parse(format_string):\r
-\r
- # output the literal text\r
- if literal_text:\r
- result.append(literal_text)\r
-\r
- # if there's a field, output it\r
- if field_name is not None:\r
- # this is some markup, find the object and do\r
- # the formatting\r
-\r
- # given the field_name, find the object it references\r
- # and the argument it came from\r
- obj, arg_used = self.get_field(field_name, args, kwargs)\r
- used_args.add(arg_used)\r
-\r
- # do any conversion on the resulting object\r
- obj = self.convert_field(obj, conversion)\r
-\r
- # expand the format spec, if needed\r
- format_spec = self._vformat(format_spec, args, kwargs,\r
- used_args, recursion_depth-1)\r
-\r
- # format the object and append to the result\r
- result.append(self.format_field(obj, format_spec))\r
-\r
- return ''.join(result)\r
-\r
-\r
- def get_value(self, key, args, kwargs):\r
- if isinstance(key, (int, long)):\r
- return args[key]\r
- else:\r
- return kwargs[key]\r
-\r
-\r
- def check_unused_args(self, used_args, args, kwargs):\r
- pass\r
-\r
-\r
- def format_field(self, value, format_spec):\r
- return format(value, format_spec)\r
-\r
-\r
- def convert_field(self, value, conversion):\r
- # do any conversion on the resulting object\r
- if conversion == 'r':\r
- return repr(value)\r
- elif conversion == 's':\r
- return str(value)\r
- elif conversion is None:\r
- return value\r
- raise ValueError("Unknown conversion specifier {0!s}".format(conversion))\r
-\r
-\r
- # returns an iterable that contains tuples of the form:\r
- # (literal_text, field_name, format_spec, conversion)\r
- # literal_text can be zero length\r
- # field_name can be None, in which case there's no\r
- # object to format and output\r
- # if field_name is not None, it is looked up, formatted\r
- # with format_spec and conversion and then used\r
- def parse(self, format_string):\r
- return format_string._formatter_parser()\r
-\r
-\r
- # given a field_name, find the object it references.\r
- # field_name: the field being looked up, e.g. "0.name"\r
- # or "lookup[3]"\r
- # used_args: a set of which args have been used\r
- # args, kwargs: as passed in to vformat\r
- def get_field(self, field_name, args, kwargs):\r
- first, rest = field_name._formatter_field_name_split()\r
-\r
- obj = self.get_value(first, args, kwargs)\r
-\r
- # loop through the rest of the field_name, doing\r
- # getattr or getitem as needed\r
- for is_attr, i in rest:\r
- if is_attr:\r
- obj = getattr(obj, i)\r
- else:\r
- obj = obj[i]\r
-\r
- return obj, first\r
projects / mirror_edk2.git / blobdiff