"""A collection of string constants.Public module variables:whitespace -- a string containing all ASCII whitespaceascii_lowercase -- a string containing all ASCII lowercase lettersascii_uppercase -- a string containing all ASCII uppercase lettersascii_letters -- a string containing all ASCII lettersdigits -- a string containing all ASCII decimal digitshexdigits -- a string containing all ASCII hexadecimal digitsoctdigits -- a string containing all ASCII octal digitspunctuation -- a string containing all ASCII punctuation charactersprintable -- a string containing all ASCII characters considered printable"""# Some strings for ctype-style character classificationwhitespace=' \t\n\r\v\f'ascii_lowercase='abcdefghijklmnopqrstuvwxyz'ascii_uppercase='ABCDEFGHIJKLMNOPQRSTUVWXYZ'ascii_letters=ascii_lowercase+ascii_uppercasedigits='0123456789'hexdigits=digits+'abcdef'+'ABCDEF'octdigits='01234567'punctuation="""!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""printable=digits+ascii_letters+punctuation+whitespace# Functions which aren't available as string methods.# Capitalize the words in a string, e.g. " aBc dEf " -> "Abc Def".defcapwords(s,sep=None):"""capwords(s [,sep]) -> string Split the argument into words using split, capitalize each word using capitalize, and join the capitalized words using join. If the optional second argument sep is absent or None, runs of whitespace characters are replaced by a single space and leading and trailing whitespace are removed, otherwise sep is used to split and join the words. """return(sepor' ').join(x.capitalize()forxins.split(sep))# Construct a translation map for bytes.translatedefmaketrans(frm:bytes,to:bytes)->bytes:"""maketrans(frm, to) -> bytes Return a translation table (a bytes object of length 256) suitable for use in bytes.translate where each byte in frm is mapped to the byte at the same position in to. The strings frm and to must be of the same length. """importwarningswarnings.warn("string.maketrans is deprecated, use bytes.maketrans instead",DeprecationWarning,2)iflen(frm)!=len(to):raiseValueError("maketrans arguments must have same length")ifnot(isinstance(frm,bytes)andisinstance(to,bytes)):raiseTypeError("maketrans arguments must be bytes objects")L=bytearray(range(256))fori,cinenumerate(frm):L[c]=to[i]returnbytes(L)####################################################################importreas_reclass_multimap:"""Helper class for combining multiple mappings. Used by .{safe_,}substitute() to combine the mapping and keyword arguments. """def__init__(self,primary,secondary):self._primary=primaryself._secondary=secondarydef__getitem__(self,key):try:returnself._primary[key]exceptKeyError:returnself._secondary[key]class_TemplateMetaclass(type):pattern=r"""%(delim)s(?: (?P<escaped>%(delim)s) | # Escape sequence of two delimiters (?P<named>%(id)s) | # delimiter and a Python identifier {(?P<braced>%(id)s)} | # delimiter and a braced identifier (?P<invalid>) # Other ill-formed delimiter exprs ) """def__init__(cls,name,bases,dct):super(_TemplateMetaclass,cls).__init__(name,bases,dct)if'pattern'indct:pattern=cls.patternelse:pattern=_TemplateMetaclass.pattern%{'delim':_re.escape(cls.delimiter),'id':cls.idpattern,}cls.pattern=_re.compile(pattern,_re.IGNORECASE|_re.VERBOSE)classTemplate(metaclass=_TemplateMetaclass):"""A string class for supporting $-substitutions."""delimiter='$'idpattern=r'[_a-z][_a-z0-9]*'def__init__(self,template):self.template=template# Search for $$, $identifier, ${identifier}, and any bare $'sdef_invalid(self,mo):i=mo.start('invalid')lines=self.template[:i].splitlines(True)ifnotlines:colno=1lineno=1else:colno=i-len(''.join(lines[:-1]))lineno=len(lines)raiseValueError('Invalid placeholder in string: line %d, col %d'%(lineno,colno))defsubstitute(self,*args,**kws):iflen(args)>1:raiseTypeError('Too many positional arguments')ifnotargs:mapping=kwselifkws:mapping=_multimap(kws,args[0])else:mapping=args[0]# Helper function for .sub()defconvert(mo):# Check the most common path first.named=mo.group('named')ormo.group('braced')ifnamedisnotNone:val=mapping[named]# We use this idiom instead of str() because the latter will# fail if val is a Unicode containing non-ASCII characters.return'%s'%(val,)ifmo.group('escaped')isnotNone:returnself.delimiterifmo.group('invalid')isnotNone:self._invalid(mo)raiseValueError('Unrecognized named group in pattern',self.pattern)returnself.pattern.sub(convert,self.template)defsafe_substitute(self,*args,**kws):iflen(args)>1:raiseTypeError('Too many positional arguments')ifnotargs:mapping=kwselifkws:mapping=_multimap(kws,args[0])else:mapping=args[0]# Helper function for .sub()defconvert(mo):named=mo.group('named')ifnamedisnotNone:try:# We use this idiom instead of str() because the latter# will fail if val is a Unicode containing non-ASCIIreturn'%s'%(mapping[named],)exceptKeyError:returnself.delimiter+namedbraced=mo.group('braced')ifbracedisnotNone:try:return'%s'%(mapping[braced],)exceptKeyError:returnself.delimiter+'{'+braced+'}'ifmo.group('escaped')isnotNone:returnself.delimiterifmo.group('invalid')isnotNone:returnself.delimiterraiseValueError('Unrecognized named group in pattern',self.pattern)returnself.pattern.sub(convert,self.template)######################################################################### the Formatter class# see PEP 3101 for details and purpose of this class# The hard parts are reused from the C implementation. They're exposed as "_"# prefixed methods of str and unicode.# The overall parser is implemented in str._formatter_parser.# The field name parser is implemented in str._formatter_field_name_splitclassFormatter:defformat(self,format_string,*args,**kwargs):returnself.vformat(format_string,args,kwargs)defvformat(self,format_string,args,kwargs):used_args=set()result=self._vformat(format_string,args,kwargs,used_args,2)self.check_unused_args(used_args,args,kwargs)returnresultdef_vformat(self,format_string,args,kwargs,used_args,recursion_depth):ifrecursion_depth<0:raiseValueError('Max string recursion exceeded')result=[]forliteral_text,field_name,format_spec,conversionin \
self.parse(format_string):# output the literal textifliteral_text:result.append(literal_text)# if there's a field, output itiffield_nameisnotNone:# this is some markup, find the object and do# the formatting# given the field_name, find the object it references# and the argument it came fromobj,arg_used=self.get_field(field_name,args,kwargs)used_args.add(arg_used)# do any conversion on the resulting objectobj=self.convert_field(obj,conversion)# expand the format spec, if neededformat_spec=self._vformat(format_spec,args,kwargs,used_args,recursion_depth-1)# format the object and append to the resultresult.append(self.format_field(obj,format_spec))return''.join(result)defget_value(self,key,args,kwargs):ifisinstance(key,int):returnargs[key]else:returnkwargs[key]defcheck_unused_args(self,used_args,args,kwargs):passdefformat_field(self,value,format_spec):returnformat(value,format_spec)defconvert_field(self,value,conversion):# do any conversion on the resulting objectifconversion=='r':returnrepr(value)elifconversion=='s':returnstr(value)elifconversionisNone:returnvalueraiseValueError("Unknown converion specifier {0!s}".format(conversion))# returns an iterable that contains tuples of the form:# (literal_text, field_name, format_spec, conversion)# literal_text can be zero length# field_name can be None, in which case there's no# object to format and output# if field_name is not None, it is looked up, formatted# with format_spec and conversion and then useddefparse(self,format_string):returnformat_string._formatter_parser()# given a field_name, find the object it references.# field_name: the field being looked up, e.g. "0.name"# or "lookup[3]"# used_args: a set of which args have been used# args, kwargs: as passed in to vformatdefget_field(self,field_name,args,kwargs):first,rest=field_name._formatter_field_name_split()obj=self.get_value(first,args,kwargs)# loop through the rest of the field_name, doing# getattr or getitem as neededforis_attr,iinrest:ifis_attr:obj=getattr(obj,i)else:obj=obj[i]returnobj,first