def str2colhead(
cls,
s_IN,
):
s_KEY = str2strip(s_IN)
if not s_KEY: raise Exception()
is_unique = s_KEY.startswith("*")
is_list = s_KEY.endswith("[]")
iSTART = 1 if is_unique else 0
iEND = -2 if is_list else len(s_IN)
name = s_KEY[iSTART:iEND]
jkey = name.split(".")
is_unique = s_KEY.startswith("*")
is_list = s_KEY.endswith("[]")
colhead = {
cls.ATTRNAME_RAW: s_IN,
cls.ATTRNAME_NAME: name,
cls.ATTRNAME_JKEY: jkey,
cls.ATTRNAME_IS_UNIQUE: is_unique,
cls.ATTRNAME_IS_LIST: is_list,
}
return colhead
def filepath2utf8_lines(
cls,
filepath,
encoding=None,
f_open=None,
):
if f_open is None:
if encoding is None: encoding = "utf-8"
f_open = lambda x: codecs.open(x, "rb", encoding=encoding)
with f_open(filepath) as f:
for s in f:
yield str2strip(s)
def str2args_kwargs_pair_NEW(
cls,
s_IN,
split_ARG_str,
):
str_PARAM_list = cls.lexer2str_DELIM_list(
cls.create_lexer(),
s_IN,
)
if not str_PARAM_list: return (None, str_PARAM_list)
return (
str2strip(str_PARAM_list[0]),
lmap(str2strip, str_PARAM_list[1:]),
)
def str2args_kwargs_pair(
cls,
s_IN,
maxsplit=None,
):
str_PARAM_list = cls.lexer2str_DELIM_list(
cls.create_lexer(),
s_IN,
maxsplit=maxsplit,
)
if not str_PARAM_list: return (None, str_PARAM_list)
return (
str2strip(str_PARAM_list[0]),
lmap(str2strip, str_PARAM_list[1:]),
)
def str2args_kwargs_pair(
cls,
s_IN,
max_args_count=None,
):
str_ARGs, h_KWARG = cls._lexer2str_ARGs_h_KWARG(
cls.create_lexer(),
str2strip(s_IN),
)
if not str_ARGs: arg_list = []
else:
maxsplit = max_args_count - 1 if max_args_count else max_args_count
l = DelimLexer.lexer2str_DELIM_list(
DelimLexer.lexer_args(),
LexerToolkit.DELIM_EXCLUDED,
str_ARGs,
maxsplit=maxsplit,
)
arg_list = lmap(StringToolkit.quoted2stripped, lmap(str2strip, l))
return (
arg_list,
h_KWARG,
)
def _lexer2str_ARGs_h_KWARG(
cls,
lexer,
s_IN,
):
lexer.input(s_IN)
tt_list_ESCAPE = ["BACKSLASH"]
tt_list_STATE = ["SQ", "DQ"]
tt_list_DELIM = [
"EQUAL",
]
str_ARGs, h_KWARG = (None, {})
kwarg_KEY = None
token_list_DELIM = []
state_INITIAL = "INITIAL"
l_state = [
state_INITIAL,
]
while True:
tok = lexer.token()
if not tok: break
state_CUR = l_state[-1]
#stop_split = (maxsplit is not None) and (len(l_OUT) >= maxsplit)
stt = LexerToolkit.tok2semantic_token_type(
tok,
token_list_DELIM,
[
tt_list_ESCAPE,
tt_list_STATE,
tt_list_DELIM,
],
False,
state_CUR,
state_INITIAL,
)
is_append_BEFORE = stt not in [LexerToolkit.STT_DELIM]
is_append_BEFORE_and_done = (stt in [LexerToolkit.STT_ANY])
if is_append_BEFORE: token_list_DELIM.append(tok)
if is_append_BEFORE_and_done: continue
if stt == LexerToolkit.STT_DELIM:
iSTART_INFIX = cls.delim_infix2iStart(
token_list_DELIM,
tt_list_DELIM,
)
if iSTART_INFIX is None: raise cls.SyntacticError()
str_PREV = str2strip(
LexerToolkit.token_list_DELIM2str_DELIM(
token_list_DELIM[:iSTART_INFIX]))
str_ARGs_THIS = cls._zzz(
str_PREV,
kwarg_KEY,
h_KWARG,
)
if str_ARGs_THIS:
if str_ARGs is not None: raise cls.SyntacticError()
str_ARGs = str_ARGs_THIS
kwarg_KEY = LexerToolkit.token_list_DELIM2str_DELIM(
token_list_DELIM[iSTART_INFIX:])
token_list_DELIM = []
#token_list_DELIM.append(tok)
continue
if stt == LexerToolkit.STT_START:
l_state.append(tok.type)
continue
if stt == LexerToolkit.STT_END:
if l_state[-1] != tok.type: raise Exception()
l_state.pop()
continue
if len(l_state) > 1: return None
if l_state[0] != state_INITIAL: return None
if token_list_DELIM:
str_PREV = str2strip(
LexerToolkit.token_list_DELIM2str_DELIM(token_list_DELIM))
str_ARGs_THIS = cls._zzz(
str_PREV,
kwarg_KEY,
h_KWARG,
)
if str_ARGs_THIS:
if str_ARGs is not None: raise cls.SyntacticError()
str_ARGs = str_ARGs_THIS
return str_ARGs, h_KWARG