|
|
@@ -96,14 +96,129 @@ def sorted(iterable, reverse=False, key=None):
|
|
|
return a
|
|
|
|
|
|
##### str #####
|
|
|
-def __f(self, *args):
|
|
|
- if '{}' in self:
|
|
|
- for i in range(len(args)):
|
|
|
- self = self.replace('{}', str(args[i]), 1)
|
|
|
- else:
|
|
|
- for i in range(len(args)):
|
|
|
- self = self.replace('{'+str(i)+'}', str(args[i]))
|
|
|
- return self
|
|
|
+def __f(self:str, *args, **kwargs) -> str:
|
|
|
+ def tokenizeString(s:str):
|
|
|
+ tokens = []
|
|
|
+ L, R = 0,0
|
|
|
+
|
|
|
+ mode = None
|
|
|
+ curArg = 0
|
|
|
+ # lookingForKword = False
|
|
|
+
|
|
|
+ while(R<len(s)):
|
|
|
+ curChar = s[R]
|
|
|
+ nextChar = s[R+1] if R+1<len(s) else ''
|
|
|
+
|
|
|
+ # Invalid case 1: stray '}' encountered, example: "ABCD EFGH {name} IJKL}", "Hello {vv}}", "HELLO {0} WORLD}"
|
|
|
+ if curChar == '}' and nextChar != '}':
|
|
|
+ raise ValueError("Single '}' encountered in format string")
|
|
|
+
|
|
|
+ # Valid Case 1: Escaping case, we escape "{{ or "}}" to be "{" or "}", example: "{{}}", "{{My Name is {0}}}"
|
|
|
+ if (curChar == '{' and nextChar == '{') or (curChar == '}' and nextChar == '}'):
|
|
|
+
|
|
|
+ if (L<R): # Valid Case 1.1: make sure we are not adding empty string
|
|
|
+ tokens.append(s[L:R]) # add the string before the escape
|
|
|
+
|
|
|
+
|
|
|
+ tokens.append(curChar) # Valid Case 1.2: add the escape char
|
|
|
+ L = R+2 # move the left pointer to the next char
|
|
|
+ R = R+2 # move the right pointer to the next char
|
|
|
+ continue
|
|
|
+
|
|
|
+ # Valid Case 2: Regular command line arg case: example: "ABCD EFGH {} IJKL", "{}", "HELLO {} WORLD"
|
|
|
+ elif curChar == '{' and nextChar == '}':
|
|
|
+ if mode is not None and mode != 'auto':
|
|
|
+ # Invalid case 2: mixing automatic and manual field specifications -- example: "ABCD EFGH {name} IJKL {}", "Hello {vv} {}", "HELLO {0} WORLD {}"
|
|
|
+ raise ValueError("Cannot switch from manual field numbering to automatic field specification")
|
|
|
+
|
|
|
+ mode = 'auto'
|
|
|
+ if(L<R): # Valid Case 2.1: make sure we are not adding empty string
|
|
|
+ tokens.append(s[L:R]) # add the string before the special marker for the arg
|
|
|
+
|
|
|
+ tokens.append("{"+str(curArg)+"}") # Valid Case 2.2: add the special marker for the arg
|
|
|
+ curArg+=1 # increment the arg position, this will be used for referencing the arg later
|
|
|
+
|
|
|
+ L = R+2 # move the left pointer to the next char
|
|
|
+ R = R+2 # move the right pointer to the next char
|
|
|
+ continue
|
|
|
+
|
|
|
+ # Valid Case 3: Key-word arg case: example: "ABCD EFGH {name} IJKL", "Hello {vv}", "HELLO {name} WORLD"
|
|
|
+ elif (curChar == '{'):
|
|
|
+
|
|
|
+ if mode is not None and mode != 'manual':
|
|
|
+ # # Invalid case 2: mixing automatic and manual field specifications -- example: "ABCD EFGH {} IJKL {name}", "Hello {} {1}", "HELLO {} WORLD {name}"
|
|
|
+ raise ValueError("Cannot switch from automatic field specification to manual field numbering")
|
|
|
+
|
|
|
+ mode = 'manual'
|
|
|
+
|
|
|
+ if(L<R): # Valid case 3.1: make sure we are not adding empty string
|
|
|
+ tokens.append(s[L:R]) # add the string before the special marker for the arg
|
|
|
+
|
|
|
+ # We look for the end of the keyword
|
|
|
+ kwL = R # Keyword left pointer
|
|
|
+ kwR = R+1 # Keyword right pointer
|
|
|
+ while(kwR<len(s) and s[kwR]!='}'):
|
|
|
+ if s[kwR] == '{': # Invalid case 3: stray '{' encountered, example: "ABCD EFGH {n{ame} IJKL {", "Hello {vv{}}", "HELLO {0} WOR{LD}"
|
|
|
+ raise ValueError("Unexpected '{' in field name")
|
|
|
+ kwR += 1
|
|
|
+
|
|
|
+ # Valid case 3.2: We have successfully found the end of the keyword
|
|
|
+ if kwR<len(s) and s[kwR] == '}':
|
|
|
+ tokens.append(s[kwL:kwR+1]) # add the special marker for the arg
|
|
|
+ L = kwR+1
|
|
|
+ R = kwR+1
|
|
|
+
|
|
|
+ # Invalid case 4: We didn't find the end of the keyword, throw error
|
|
|
+ else:
|
|
|
+ raise ValueError("Expected '}' before end of string")
|
|
|
+ continue
|
|
|
+
|
|
|
+ R = R+1
|
|
|
+
|
|
|
+
|
|
|
+ # Valid case 4: We have reached the end of the string, add the remaining string to the tokens
|
|
|
+ if L<R:
|
|
|
+ tokens.append(s[L:R])
|
|
|
+
|
|
|
+ # print(tokens)
|
|
|
+ return tokens
|
|
|
+
|
|
|
+ tokens = tokenizeString(self)
|
|
|
+ argMap = {}
|
|
|
+ for i, a in enumerate(args):
|
|
|
+ argMap[str(i)] = a
|
|
|
+ final_tokens = []
|
|
|
+ for t in tokens:
|
|
|
+ if t[0] == '{' and t[-1] == '}':
|
|
|
+ key = t[1:-1]
|
|
|
+ argMapVal = argMap.get(key, None)
|
|
|
+ kwargsVal = kwargs.get(key, None)
|
|
|
+
|
|
|
+ if argMapVal is None and kwargsVal is None:
|
|
|
+ raise ValueError("No arg found for token: "+t)
|
|
|
+ elif argMapVal is not None:
|
|
|
+ final_tokens.append(str(argMapVal))
|
|
|
+ else:
|
|
|
+ final_tokens.append(str(kwargsVal))
|
|
|
+ else:
|
|
|
+ final_tokens.append(t)
|
|
|
+
|
|
|
+ return ''.join(final_tokens)
|
|
|
+
|
|
|
+ # if '{}' in self:
|
|
|
+ # for i in range(len(args)):
|
|
|
+ # self = self.replace('{}', str(args[i]), 1)
|
|
|
+ # else:
|
|
|
+ # # Positional arguments will be followed by keyword arguments
|
|
|
+ # # 1. Replace the positional arguments
|
|
|
+ # for i,a in enumerate(args):
|
|
|
+ # self = self.replace('{'+str(i)+'}', str(a))
|
|
|
+
|
|
|
+ # # 2. Replace the keyword arguments
|
|
|
+ # for k,v in kwargs.items():
|
|
|
+ # self = self.replace('{'+k+'}', str(v))
|
|
|
+
|
|
|
+ # return self
|
|
|
str.format = __f
|
|
|
|
|
|
def __f(self, chars=None):
|
BLUELOVETH