def get_dflt_block_op_pairs_dict(**kwargs): if('block_op_pairs' in kwargs): block_op_pairs = kwargs['block_op_pairs'] if(utils.is_dict(block_op_pairs)): block_op_pairs_dict = block_op_pairs else: block_op_pairs_dict = block.get_block_op_pairs(block_op_pairs) else: block_op_pairs_dict = block.get_block_op_pairs('{}[]()') return(block_op_pairs_dict)
def get_print_lines_and_paths(j_str,**kwargs): #### sp = eftl.dflt_kwargs("sp",'/',**kwargs) spaces = eftl.dflt_kwargs("spaces",[' ','\t'],**kwargs) colons = eftl.dflt_kwargs("colons",[':'],**kwargs) commas = eftl.dflt_kwargs("commas",[','],**kwargs) line_sps = eftl.dflt_kwargs("line_sps",['\r','\n'],**kwargs) block_op_pairs_dict = eftl.dflt_kwargs('block_op_pairs_dict',block.get_block_op_pairs('{}[]()'),**kwargs) quotes_pairs_dict = eftl.dflt_kwargs('quotes_pairs_dict',quote.get_quotes_pairs('""\'\'')) path_sps = eftl.dflt_kwargs('path_sps',['/'],**kwargs) fixed_indent = eftl.dflt_kwargs('fixed_indent',0,**kwargs) indent = eftl.dflt_kwargs('indent',4,**kwargs) #step0 quote j_str = convert_token_in_quote( j_str, block_op_pairs_dict=block_op_pairs_dict, quotes_pairs_dict=quotes_pairs_dict, spaces=spaces, colons=colons, commas=commas, line_sps=line_sps, path_sps=path_sps ) #step1 format j_str = fmt_jstr.format_j_str(j_str,block_op_pairs_dict) #step2 char-level-of-block j_lv_str = tokenize_block.get_j_str_lvs_dict(j_str,block_op_pairs_dict) orig_lines = j_str.split('\n') line_start_indexes = get_line_start_index_in_j_str(orig_lines) new_lines = {} #step 1: line 0 prev_lv = int(j_lv_str[line_start_indexes[0]]) prev_path = line_to_path_init(orig_lines[0],block_op_pairs_dict,sp,commas,colons) #----------should not unescape here for secarino:{'resp_body_bytes': b''c'} # which will cause {'resp_body_bytes': b''c'} new_lines[0] = orig_lines[0] #----------should not unescape here paths = {} paths = {0: prev_path} for i in range(1, orig_lines.__len__()): curr_lv = int(j_lv_str[line_start_indexes[i]]) curr_path = line_to_path(orig_lines[i],curr_lv,prev_lv,prev_path,block_op_pairs_dict,sp,commas,colons) paths[i] = curr_path curr_head = utils.path_string_get_head(curr_path,delimiter=sp) if(fixed_indent): prepend = " " * indent * (curr_head.count(sp) - 1) else: curr_head = curr_head.replace(sp,'') #---escaped to calculate the real prepend spaces curr_head = html.unescape(curr_head) #---escaped to calculate the real prepend spaces curr_head_len = curr_head.__len__() prepend = " " * curr_head_len #------------should not unescape here new_lines[i] = ''.join((prepend,orig_lines[i])) #------------should not unescape here prev_lv = curr_lv prev_path = curr_path return({'lines':new_lines,'paths':paths})
def get_jdict_token_set(**kwargs): ''' from xdict.jprint import get_jdict_token_set get_jdict_token_set(quotes_pairs_dict={1: ('"', '"'), 2: ("<", ">")}) ''' spaces = eftl.dflt_kwargs("spaces", [' ', '\t'], **kwargs) colons = eftl.dflt_kwargs("colons", [':'], **kwargs) commas = eftl.dflt_kwargs("commas", [','], **kwargs) line_sps = eftl.dflt_kwargs("line_sps", ['\r', '\n'], **kwargs) block_op_pairs_dict = eftl.dflt_kwargs("block_op_pairs_dict", block.get_block_op_pairs('{}[]()'), **kwargs) quotes_pairs_dict = eftl.dflt_kwargs("quotes_pairs_dict", quote.get_quotes_pairs('""\'\''), **kwargs) lquotes, rquotes, quotes = quote.get_lrquotes(quotes_pairs_dict) path_sps = eftl.dflt_kwargs("path_sps", ['/']) ####### d = {} s = set({}) def add_bi_table(s, d, x): for each in x: k = each v = escape.html_number_escape_str(k) d[k] = v d[v] = k s.add(k) add_bi_table(s, d, spaces) add_bi_table(s, d, colons) add_bi_table(s, d, commas) add_bi_table(s, d, line_sps) add_bi_table(s, d, lquotes) add_bi_table(s, d, rquotes) add_bi_table(s, d, path_sps) for i in range(1, block_op_pairs_dict.__len__() + 1): s.add(block_op_pairs_dict[i][0]) s.add(block_op_pairs_dict[i][1]) recover_token_l = escape.html_number_escape_str( block_op_pairs_dict[i][0]) recover_token_r = escape.html_number_escape_str( block_op_pairs_dict[i][1]) d[block_op_pairs_dict[i][0]] = recover_token_l d[block_op_pairs_dict[i][1]] = recover_token_r d[recover_token_l] = block_op_pairs_dict[i][0] d[recover_token_r] = block_op_pairs_dict[i][1] return ({'token_set': s, 'replace_ref_dict': d})
def get_j_str_lvs_dict(j_str,block_op_pairs_dict=block.get_block_op_pairs("{}[]()")): j_str_len = j_str.__len__() j_str_lvs_dict = {} if( j_str_len == 0): j_str_lvs_dict = {} elif(j_str_len == 1): j_str_lvs_dict = {0:1} else: curr_lv = 1 j_str_lvs_dict = {0:1} seq = 1 curr_seq = 0 while(curr_seq < j_str_len - 1): level,curr_lv,curr_seq = get_next_char_level_in_j_str(curr_lv,curr_seq,j_str,block_op_pairs_dict) j_str_lvs_dict[seq] =level seq = seq + 1 return(j_str_lvs_dict)
def line_to_path_init( line, block_op_pairs_dict = block.get_block_op_pairs("{}[]()"), sp='/', commas=[','], colons=[':'] ): end = line.rstrip(' ')[-1] if(is_colon(end,colons)): curr_base_name = ''.join((line,sp)) elif(block.is_lop(end,block_op_pairs_dict)): curr_base_name = ''.join((line,sp)) elif(is_comma(end,commas)): curr_base_name = line elif(block.is_rop(end,block_op_pairs_dict)): curr_base_name = line else: curr_base_name = line curr_path = ''.join((sp,curr_base_name)) return(curr_path)
def get_next_char_level_in_j_str(curr_lv,curr_seq,j_str,block_op_pairs_dict=block.get_block_op_pairs("{}[]()")): ''' the first-char is level-1 when current is non-op, next-char-level = curr-level when current is lop, non-paired-rop-next-char-level = lop-level+1; when current is lop, paired-rop-next-char-level = lop-level when current is rop, next-char-level = rop-level - 1 # {"key_4_UF0aJJ6v": "value_1", "key_2_Hd0t": ["value_16", "value_8", "value_8", "value_15", "value_14", "value_19", {...... # 122222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333334...... # {\n"key_4_UF0aJJ6v": "value_1", \n"key_2_Hd0t": [\n"value_16", \n"value_8", \n"value_8", \n"value_15", \n"value_14", \n"value_19",...... # 1 222222222222222222222222222222 2222222222222222 3333333333333 333333333333 333333333333 3333333333333 3333333333333 3333333333333...... ''' curr_ch = j_str[curr_seq] next_ch = j_str[curr_seq + 1] cond = 0 for i in range(1,block_op_pairs_dict.__len__()+1): if(curr_ch == block_op_pairs_dict[i][0]): if(next_ch == block_op_pairs_dict[i][1]): next_lv = curr_lv else: next_lv = curr_lv + 1 cond = 1 break elif(curr_ch == block_op_pairs_dict[i][1]): if(block.is_rop(next_ch,block_op_pairs_dict)): next_lv = curr_lv - 1 else: next_lv = curr_lv cond = 1 break else: pass if(cond == 1): pass elif(block.is_rop(next_ch,block_op_pairs_dict)): next_lv = curr_lv - 1 else: next_lv = curr_lv curr_lv = next_lv curr_seq = curr_seq + 1 return(curr_lv,curr_lv,curr_seq)
def prepare_quotes_token_machine(j_str, **kwargs): ''' >>> from xdict.jprint import convert_token_in_quote >>> from xdict.jprint import help >>> >>> convert_token_in_quote('"a b":"cd"') '"a b":"cd"' >>> import html >>> html.unescape('"a b":"cd"') '"a b":"cd"' >>> convert_token_in_quote('"a b":cd') '"a b":cd' >>> >>> #help(convert_token_in_quote) convert_token_in_quote('<a b>:"cd"',quotes_pairs_dict={1: ('"', '"'), 2: ("<", ">")}) '<a b>:"cd"' ''' #### spaces = eftl.dflt_kwargs("spaces", [' ', '\t'], **kwargs) colons = eftl.dflt_kwargs("colons", [':'], **kwargs) commas = eftl.dflt_kwargs("commas", [','], **kwargs) line_sps = eftl.dflt_kwargs("line_sps", ['\r', '\n'], **kwargs) block_op_pairs_dict = eftl.dflt_kwargs("block_op_pairs_dict", get_block_op_pairs('{}[]()'), **kwargs) quotes_pairs_dict = eftl.dflt_kwargs("quotes_pairs_dict", get_quotes_pairs('""\'\''), **kwargs) lquotes, rquotes, quotes = get_lrquotes(quotes_pairs_dict) path_sps = eftl.dflt_kwargs("path_sps", ['/']) #### temp = get_jdict_token_set(**kwargs) token_set = temp['token_set'] replace_ref_dict = temp['replace_ref_dict'] #### # ----------------------------------------------------------------- # #### def do_replace(ch): if (ch in token_set): ch = replace_ref_dict[ch] return (ch) def do_throw(curr_state, trigger_checker, input_symbol): msg = "curr_state: " + curr_state + "\n" msg = msg + "trigger_checker: " + trigger_checker.__str__() + "\n" msg = msg + "input_symbol: " + input_symbol.__str__() + "\n" msg = msg + "triggered ERROR" + "\n" raise Exception(msg) #### machine = fsm.FSM() regex_lquotes = fsm.creat_regex_from_arr(lquotes) regex_rquotes = fsm.creat_regex_from_arr(rquotes) regex_b = re.compile('b') regex_spaces = fsm.creat_regex_from_arr(spaces) regex_colons = fsm.creat_regex_from_arr(colons) regex_commas = fsm.creat_regex_from_arr(commas) regex_slash = re.compile("\\\\") ###### ops = [] for i in range(1, block_op_pairs_dict.__len__() + 1): ops.append(block_op_pairs_dict[i][0]) ops.append(block_op_pairs_dict[i][1]) ###### regex_ops = fsm.creat_regex_from_arr(ops) LqRqBSpColComSlOp_arr = ['b', '\\\\'] LqRqBSpColComSlOp_arr = LqRqBSpColComSlOp_arr + lquotes + rquotes + spaces + colons + commas + ops regex_not_LqRqBSpColComSlOp = fsm.creat_regex_not_from_arr( LqRqBSpColComSlOp_arr) # ############################ # ############################ machine.add("INIT", regex_b, None, "BYTES") machine.add("INIT", regex_spaces, None, "INIT") machine.add("INIT", regex_ops, None, "INIT") machine.add("INIT", regex_colons, None, "INIT") machine.add("INIT", regex_commas, None, "INIT") machine.add("INIT", regex_slash, None, "SLASHINIT") machine.add("INIT", regex_not_LqRqBSpColComSlOp, do_replace, "OTHER") #### machine.add("BYTES", regex_b, None, "OTHER") machine.add("BYTES", regex_spaces, None, "BYTES") machine.add("BYTES", regex_ops, None, "INIT") machine.add("BYTES", regex_colons, None, "INIT") machine.add("BYTES", regex_commas, None, "INIT") machine.add("BYTES", regex_slash, None, "SLASHBYTES") machine.add("BYTES", regex_not_LqRqBSpColComSlOp, do_replace, "OTHER") #### machine.add("SLASHINIT", re.compile("."), do_replace, "OTHER") #### machine.add("SLASHBYTES", re.compile("."), do_replace, "OTHER") #### machine.add("OTHER", regex_b, None, "OTHER") machine.add("OTHER", regex_spaces, None, "OTHER") machine.add("OTHER", regex_ops, None, "INIT") machine.add("OTHER", regex_colons, None, "INIT") machine.add("OTHER", regex_commas, None, "INIT") machine.add("OTHER", regex_slash, None, "SLASHOTHER") machine.add("OTHER", regex_not_LqRqBSpColComSlOp, do_replace, "OTHER") #### machine.add("SLASHOTHER", re.compile("."), do_replace, "OTHER") #### regex_lquote_array = fsm.creat_regexes_array(lquotes) regex_rquote_array = fsm.creat_regexes_array(rquotes) ###@@@@@@@@@@@@@@@ for i in range(0, lquotes.__len__()): ####INIT -lq_n-> LQ_n sn = ''.join(("LQ", '_', str(i))) machine.add("INIT", regex_lquote_array[i], None, sn) for i in range(0, rquotes.__len__()): ####INIT -rq_n-> ERROR if (regex_rquote_array[i] == regex_lquote_array[i]): pass else: sn = ''.join(("LQ", '_', str(i))) machine.add("INIT", regex_rquote_array[i], do_throw, 'ERROR') #### for i in range(0, lquotes.__len__()): ####BYTES -lq_n-> LQ_n sn = ''.join(("LQ", '_', str(i))) machine.add("BYTES", regex_lquote_array[i], None, sn) for i in range(0, rquotes.__len__()): ####BYTES -rq_n-> ERROR if (rquotes[i] == lquotes[i]): pass else: sn = ''.join(("LQ", '_', str(i))) machine.add("BYTES", regex_rquote_array[i], do_throw, 'ERROR') #### for i in range(0, lquotes.__len__()): ####OTHER -lq_n-> LQ_n sn = ''.join(("LQ", '_', str(i))) machine.add("OTHER", regex_lquote_array[i], None, sn) for i in range(0, rquotes.__len__()): ####OTHER -rq_n-> ERROR if (rquotes[i] == lquotes[i]): pass else: sn = ''.join(("LQ", '_', str(i))) machine.add("OTHER", regex_rquote_array[i], do_throw, 'ERROR') #### for i in range(0, lquotes.__len__()): ####LQ_n -lq_n-> ERROR sn = ''.join(("LQ", '_', str(i))) if (lquotes[i] == rquotes[i]): pass else: machine.add(sn, regex_lquote_array[i], do_throw, 'ERROR') ####LQ_n -rq_n-> READY machine.add(sn, regex_rquote_array[i], None, 'INIT') #####LQ_n -b-> LQ_n machine.add(sn, regex_b, None, sn) #####LQ_n -spaces-> LQ_n machine.add(sn, regex_spaces, do_replace, sn) #####LQ_n -ops-> LQ_n machine.add(sn, regex_ops, do_replace, sn) ####LQ_n -colons-> LQ_n machine.add(sn, regex_colons, do_replace, sn) ####LQ_n -commas-> LQ_n machine.add(sn, regex_commas, do_replace, sn) #####LQ_n -slash -> SLASHLQ_n slashlq = ''.join(("SLASHLQ", '_', str(i))) machine.add(sn, re.compile("\\\\"), None, slashlq) ####SLASHLQ_n -any-> LQ_n machine.add(slashlq, re.compile("."), do_replace, sn) #####LQ_n -others-> LQ_n tmp_arr = ['b', '\\\\'] + ops + colons + commas + spaces tmp_arr_rq = [rquotes[i]] tmp_arr_lq = [lquotes[i]] if (lquotes[i] == rquotes[i]): tmp_arr_rq = [] else: pass tmp_final_arr = tmp_arr + tmp_arr_rq + tmp_arr_lq #### tmp_regex = fsm.creat_regex_not_from_arr(tmp_final_arr) machine.add(sn, tmp_regex, do_replace, sn) #### machine.orig_str = j_str machine.do_replace = do_replace machine.do_throw = do_throw #### return (machine)
def line_to_path( line,curr_lv, prev_lv, prev_path, block_op_pairs_dict= block.get_block_op_pairs("{}[]()"), sp='/', commas=[','], colons=[':'] ): def no_space_tail(tail): tail_no_space = tail.rstrip(' ') for i in range(0,commas.__len__()): tail_no_space_2 = utils.str_rstrip(tail_no_space,commas[i],1) if(tail_no_space_2 == tail_no_space): pass else: tail_no_space = tail_no_space_2 break tail_no_space = utils.str_rstrip(tail_no_space,sp,1) tail_no_space = tail_no_space.rstrip(' ') return(tail_no_space) # if end with path_sp sp,it means this is not a leaf, its recursived # '/{/' # "/'Error': None, " # "/'Value': /" # '/{/' # "/'MyRulesHtml': '<div></div>', " # "/'__type': 'RuleDesignerRuleResult', " curr_base_name = line_to_path_init(line,block_op_pairs_dict ,sp,commas,colons) curr_base_name = utils.str_lstrip(curr_base_name,'/',1) head = utils.path_string_get_head(prev_path,delimiter=sp) head_head = utils.path_string_get_head(head,delimiter=sp) head_tail = utils.path_string_get_tail(head,delimiter=sp) head_tail_no_space = no_space_tail(head_tail) # if(curr_lv > prev_lv): curr_path = ''.join((prev_path,curr_base_name)) elif(curr_lv == prev_lv): prev_last_no_space = utils.str_rstrip(prev_path,sp,1) prev_last_no_space = prev_last_no_space.rstrip(' ') prev_last = prev_last_no_space[-1] prev_op = prev_path.rstrip(' ') for i in range(0,commas.__len__()): prev_rop = utils.str_rstrip(prev_op,commas[i],1) if(prev_op == prev_rop): pass else: prev_rop = prev_rop[-1] break # secarino_1: if(is_colon(prev_last)): curr_path = ''.join((prev_path,curr_base_name)) elif(block.is_rop(prev_rop,block_op_pairs_dict)): tail = utils.path_string_get_tail(prev_path,delimiter=sp) tail_no_space = no_space_tail(tail) tail_len = tail_no_space.__len__() # secarino_2 if( (tail_len == 1) & (is_colon(head_tail_no_space[-1]))): curr_path = ''.join((head_head,curr_base_name)) # secarino_3 elif(tail_len == 1): curr_path = ''.join((head,curr_base_name)) # secarino_4 elif((tail_len == 2) & (is_colon(head_tail_no_space[-1]))): curr_path = ''.join((head_head,curr_base_name)) # secarino_5 else: curr_path = ''.join((head,curr_base_name)) #secarino_6: else: curr_path = ''.join((head,curr_base_name)) else: if(is_colon(head_tail_no_space[-1])): #secarino_8 curr_path = ''.join((utils.path_string_get_head(head_head,delimiter=sp),curr_base_name)) else: #secarino_7 curr_path = ''.join((head_head,curr_base_name)) return(curr_path)
def pdir(obj,*args,**kwargs): ''' >>> import os >>> from xdict.jprint import pdir >>> pdir(os,range=(1,10)) [ 'CLD_DUMPED', 'CLD_EXITED', 'CLD_TRAPPED', 'EX_CANTCREAT', 'EX_CONFIG', 'EX_DATAERR', 'EX_IOERR', 'EX_NOHOST', 'EX_NOINPUT' ] >>> ''' obj = dir(obj) try: start = args[0] except: start = 0 else: pass try: end = args[1] except: end = 2 ** 32 else: pass if('egrep' in kwargs): nobj = [] for each in obj: if(kwargs['egrep'] in each): nobj.append(each) else: pass obj = nobj else: pass if('range' in kwargs): start = kwargs['range'][0] end = kwargs['range'][1] else: pass sp = eftl.dflt_kwargs("sp",'/',**kwargs) spaces = eftl.dflt_kwargs("spaces",[' ','\t'],**kwargs) colons = eftl.dflt_kwargs("colons",[':'],**kwargs) commas = eftl.dflt_kwargs("commas",[','],**kwargs) line_sps = eftl.dflt_kwargs("line_sps",['\r','\n'],**kwargs) block_op_pairs_dict = eftl.dflt_kwargs('block_op_pairs_dict',block.get_block_op_pairs('{}[]()'),**kwargs) quotes_pairs_dict = eftl.dflt_kwargs('quotes_pairs_dict',quote.get_quotes_pairs('""\'\'')) path_sps = eftl.dflt_kwargs('path_sps',['/'],**kwargs) fixed_indent = eftl.dflt_kwargs('fixed_indent',0,**kwargs) indent = eftl.dflt_kwargs('indent',4,**kwargs) quotes_pairs_dict = get_dflt_quotes_pairs_dict(**kwargs) block_op_pairs_dict = get_dflt_block_op_pairs_dict(**kwargs) if('with_color' in kwargs): with_color = kwargs['with_color'] else: with_color = 1 if(with_color): if('key_color' in kwargs): key_color = kwargs['key_color'] else: key_color=KEY_COLOR if('value_color' in kwargs): value_color = kwargs['value_color'] else: value_color=VALUE_COLOR if('list_ele_color' in kwargs): list_ele_color = kwargs['list_ele_color'] else: list_ele_color=LIST_ELE_COLOR if('op_color' in kwargs): op_color = kwargs['op_color'] else: op_color=OP_COLOR if('default_color' in kwargs): default_color = kwargs['default_color'] else: default_color=DEFAULT_COLOR else: pass if('start' in kwargs): start = kwargs['start'] else: pass if('end' in kwargs): end = kwargs['end'] else: pass ### obj = obj[start:end] ### if(with_color): pobj(obj,spaces=spaces,colons=colons,commas=commas,line_sps = line_sps,path_sps = path_sps,sp=sp,with_color=with_color,block_op_pairs=block_op_pairs_dict,quotes_pairs=quotes_pairs_dict,key_color=key_color,value_color=value_color,list_ele_color=list_ele_color,op_color=op_color,default_color=default_color,display=1,fixed_indent=fixed_indent,indent=indent) else: pobj(obj,spaces=spaces,colons=colons,commas=commas,line_sps = line_sps,path_sps = path_sps,sp=sp,with_color=with_color,block_op_pairs=block_op_pairs_dict,quotes_pairs=quotes_pairs_dict,fixed_indent=fixed_indent,indent=indent,display=1)
def pobj(obj,*args,**kwargs): ''' pobj(eles,quotes_pairs="''\"\"<>") pobj(eles,block_op_pairs="{}[]()") ''' try: start = args[0] except: start = 0 else: pass try: end = args[1] except: end = 2 ** 32 else: pass sp = eftl.dflt_kwargs("sp",'/',**kwargs) spaces = eftl.dflt_kwargs("spaces",[' ','\t'],**kwargs) colons = eftl.dflt_kwargs("colons",[':'],**kwargs) commas = eftl.dflt_kwargs("commas",[','],**kwargs) line_sps = eftl.dflt_kwargs("line_sps",['\r','\n'],**kwargs) block_op_pairs_dict = eftl.dflt_kwargs('block_op_pairs_dict',block.get_block_op_pairs('{}[]()'),**kwargs) quotes_pairs_dict = eftl.dflt_kwargs('quotes_pairs_dict',quote.get_quotes_pairs('""\'\'')) path_sps = eftl.dflt_kwargs('path_sps',['/'],**kwargs) fixed_indent = eftl.dflt_kwargs('fixed_indent',0,**kwargs) indent = eftl.dflt_kwargs('indent',4,**kwargs) quotes_pairs_dict = get_dflt_quotes_pairs_dict(**kwargs) block_op_pairs_dict = get_dflt_block_op_pairs_dict(**kwargs) if('with_color' in kwargs): with_color = kwargs['with_color'] else: with_color = 1 if(with_color): if('key_color' in kwargs): key_color = kwargs['key_color'] else: key_color=KEY_COLOR if('value_color' in kwargs): value_color = kwargs['value_color'] else: value_color=VALUE_COLOR if('list_ele_color' in kwargs): list_ele_color = kwargs['list_ele_color'] else: list_ele_color=LIST_ELE_COLOR if('op_color' in kwargs): op_color = kwargs['op_color'] else: op_color=OP_COLOR if('default_color' in kwargs): default_color = kwargs['default_color'] else: default_color=DEFAULT_COLOR if('start' in kwargs): start = kwargs['start'] else: pass ########## ############1 if('end' in kwargs): end = kwargs['end'] else: pass if(utils.is_str(obj)): s = obj else: s = obj.__str__() if(with_color): print_j_str(s,spaces=spaces,colons=colons,commas=commas,line_sps = line_sps,path_sps = path_sps,sp=sp,with_color=with_color,block_op_pairs=block_op_pairs_dict,quotes_pairs=quotes_pairs_dict,key_color=key_color,value_color=value_color,list_ele_color=list_ele_color,op_color=op_color,default_color=default_color,display=1,start=start,end=end,fixed_indent=fixed_indent,indent=indent) else: print_j_str(s,spaces=spaces,colons=colons,commas=commas,line_sps = line_sps,path_sps = path_sps,sp=sp,with_color=with_color,block_op_pairs=block_op_pairs_dict,quotes_pairs=quotes_pairs_dict,start=start,end=end,fixed_indent=fixed_indent,indent=indent,display=1)
def print_j_str(j_str,**kwargs): if('display' in kwargs): display = kwargs['display'] else: display = 0 if('spaces' in kwargs): spaces = kwargs['spaces'] else: spaces = [' ','\t'] if('colons' in kwargs): colons = kwargs['colons'] else: colons = [':'] if('commas' in kwargs): commas = kwargs['commas'] else: commas = [','] if('line_sps' in kwargs): line_sps = kwargs['line_sps'] else: line_sps = ['\r','\n'] #if('quotes' in kwargs): # quotes = kwargs['quotes'] #else: # quotes = ['"',"'"] ########## ############ if('path_sps' in kwargs): path_sps = kwargs['path_sps'] else: path_sps = ['/'] if('fixed_indent' in kwargs): fixed_indent = kwargs['fixed_indent'] else: fixed_indent =0 if('indent' in kwargs): indent = kwargs['indent'] else: indent =4 if('sp' in kwargs): sp = kwargs['sp'] else: sp = '/' if('with_color' in kwargs): with_color = kwargs['with_color'] else: with_color = 1 if(with_color): if('key_color' in kwargs): key_color = kwargs['key_color'] else: key_color=KEY_COLOR if('value_color' in kwargs): value_color = kwargs['value_color'] else: value_color=VALUE_COLOR if('list_ele_color' in kwargs): list_ele_color = kwargs['list_ele_color'] else: list_ele_color=LIST_ELE_COLOR if('op_color' in kwargs): op_color = kwargs['op_color'] else: op_color=OP_COLOR if('default_color' in kwargs): default_color = kwargs['default_color'] else: default_color=DEFAULT_COLOR ###### if('quotes_pairs' in kwargs): quotes_pairs = kwargs['quotes_pairs'] if(utils.is_dict(quotes_pairs)): quotes_pairs_dict = quotes_pairs else: quotes_pairs_dict = quote.get_quotes_pairs(quotes_pairs) else: quotes_pairs_dict = quote.get_quotes_pairs('""\'\'') if('block_op_pairs' in kwargs): block_op_pairs = kwargs['block_op_pairs'] if(utils.is_dict(block_op_pairs)): block_op_pairs_dict = block_op_pairs else: block_op_pairs_dict = block.get_block_op_pairs(block_op_pairs) else: block_op_pairs_dict = block.get_block_op_pairs('{}[]()') lps = get_print_lines_and_paths(j_str,sp=sp,block_op_pairs_dict=block_op_pairs_dict,quotes_pairs_dict=quotes_pairs_dict,spaces=spaces,colons=colons,commas=commas,line_sps=line_sps,path_sps=path_sps,fixed_indent=fixed_indent,indent=indent) lines = lps['lines'] paths = lps['paths'] try: start = args[0] except: start = 0 else: pass try: end = args[1] except: end = lines.__len__()-1 else: pass if('start' in kwargs): start = kwargs['start'] else: pass if('end' in kwargs): end = kwargs['end'] else: pass if(end > lines.__len__()): end = lines.__len__()-1 #-----------------------------------------careful paths not escaped but lines escaped====>>> painted_lines = {} for i in range(start,end+1): line = lines[i] if(with_color): color_sec = get_line_color_sec(line,paths[i],block_op_pairs=block_op_pairs_dict,quotes_pairs=quotes_pairs_dict,key_color=key_color,value_color=value_color,list_ele_color=list_ele_color,op_color=op_color,default_color=default_color,spaces=spaces,colons=colons,commas=commas,line_sps = line_sps,path_sps = path_sps,sp=sp) painted_string = paint(line,color_sec=color_sec,rtrn=True,mode=8) #-------fix issues--- when pobj({'resp_body_bytes': b''c'}) painted_string = html.unescape(painted_string) #-------fix issues--- when pobj({'resp_body_bytes': b''c'}) else: color_sec = None #-------fix issues--- when pobj({'resp_body_bytes': b''c'}) painted_string = html.unescape(line) #-------fix issues--- when pobj({'resp_body_bytes': b''c'}) #not implemented yet # if(fixed_indent): # indent_num = paths[i].split(sp).__len__() # curr_head_len = indent * indent_num # else: painted_lines[i] = painted_string #### #if(display): # print(painted_lines[i]) #else: # pass if(IS_WIN): pass else: if(display): s = elel.join(painted_lines,"\n") print(s) else: pass return(painted_lines)
def get_line_color_sec(line,path,**kwargs): sp = eftl.dflt_kwargs("sp",'/',**kwargs) spaces = eftl.dflt_kwargs("spaces",[' ','\t'],**kwargs) colons = eftl.dflt_kwargs("colons",[':'],**kwargs) commas = eftl.dflt_kwargs("commas",[','],**kwargs) line_sps = eftl.dflt_kwargs("line_sps",['\r','\n'],**kwargs) block_op_pairs_dict = eftl.dflt_kwargs('block_op_pairs_dict',block.get_block_op_pairs('{}[]()'),**kwargs) quotes_pairs_dict = eftl.dflt_kwargs('quotes_pairs_dict',quote.get_quotes_pairs('""\'\'')) path_sps = eftl.dflt_kwargs('path_sps',['/'],**kwargs) fixed_indent = eftl.dflt_kwargs('fixed_indent',0,**kwargs) indent = eftl.dflt_kwargs('indent',4,**kwargs) #### if('block_op_pairs' in kwargs): block_op_pairs = kwargs['block_op_pairs'] if(utils.is_dict(block_op_pairs)): block_op_pairs_dict = block_op_pairs else: block_op_pairs_dict = block.get_block_op_pairs(block_op_pairs) else: block_op_pairs_dict = block.get_block_op_pairs('{}[]()') if('block_non_ordered_op_pairs' in kwargs): block_non_ordered_op_pairs = kwargs['block_non_ordered_op_pairs'] if(utils.is_dict(block_non_ordered_op_pairs)): block_non_ordered_op_pairs_dict = block_non_ordered_op_pairs else: block_non_ordered_op_pairs_dict = block.get_block_op_pairs(block_non_ordered_op_pairs) else: block_non_ordered_op_pairs_dict = block.get_block_op_pairs('{}') #### if('quotes_pairs' in kwargs): quotes_pairs = kwargs['quotes_pairs'] if(utils.is_dict(quotes_pairs)): quotes_pairs_dict = quotes_pairs else: quotes_pairs_dict = quote.get_quotes_pairs(quotes_pairs) else: quotes_pairs_dict = quote.get_quotes_pairs('""\'\'') lquotes = [] rquotes = [] quotes = [] for i in range(1,quotes_pairs_dict.__len__()+1): lquotes.append(quotes_pairs_dict[i][0]) rquotes.append(quotes_pairs_dict[i][1]) quotes.append(quotes_pairs_dict[i][0]) quotes.append(quotes_pairs_dict[i][1]) #### if('key_color' in kwargs): key_color = kwargs['key_color'] else: key_color=KEY_COLOR if('value_color' in kwargs): value_color = kwargs['value_color'] else: value_color=VALUE_COLOR if('list_ele_color' in kwargs): list_ele_color = kwargs['list_ele_color'] else: list_ele_color=LIST_ELE_COLOR if('op_color' in kwargs): op_color = kwargs['op_color'] else: op_color=OP_COLOR if('default_color' in kwargs): default_color = kwargs['default_color'] else: default_color=DEFAULT_COLOR #------------------------------------------------------------ line_len = line.__len__() si = 0 ei = 0 color_sec = {} color_sec_seq = 1 colon_meeted = 0 byte_meeted = 0 #------------------------------------------------------------- ops = [] for i in range(1,block_op_pairs_dict.__len__()+1): ops.append(block_op_pairs_dict[i][0]) ops.append(block_op_pairs_dict[i][1]) ###### machine = fsm.FSM() # #machine.enable_debug = True # regex_lquotes = fsm.creat_regex_from_arr(lquotes) regex_rquotes = fsm.creat_regex_from_arr(rquotes) regex_b = re.compile('b') regex_spaces = fsm.creat_regex_from_arr(spaces) regex_colons = fsm.creat_regex_from_arr(colons) regex_commas = fsm.creat_regex_from_arr(commas) regex_slash = re.compile("\\\\") regex_ops = fsm.creat_regex_from_arr(ops) LqRqBSpColComSlOp_arr = ['b','\\\\'] LqRqBSpColComSlOp_arr = LqRqBSpColComSlOp_arr + lquotes + rquotes + spaces + colons+commas + ops regex_not_LqRqBSpColComSlOp = fsm.creat_regex_not_from_arr(LqRqBSpColComSlOp_arr) #------------------------------------------------------------------- head = utils.path_string_get_head(path) head_last = utils.str_rstrip(head,sp,1) head_last = utils.str_rstrip(head_last," ",1) if(head_last == ''): pass else: head_last = head_last[-1] #------------------------------------------------------ def do_throw(curr_state,trigger_checker,input_symbol,line,path,index): msg = "curr_state: " + curr_state + "\n" msg = msg + "trigger_checker: "+trigger_checker.__str__() + "\n" msg = msg + "input_symbol: "+ input_symbol.__str__() + "\n" msg = msg + "triggered ERROR" + "\n" msg = msg + line + "\n" msg = msg + path + "\n" mas = msg + "index : " + str(index) raise Exception(msg) def do_open_quote(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted): byte_meeted = 0 #### ei = cursor curr_color = default_color color_sec[color_sec_seq] = (si,ei,curr_color) color_sec_seq = color_sec_seq + 1 si = cursor + 1 return(si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted) def do_close_quote(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted): ei = cursor - 1 if(colon_meeted): curr_color = value_color else: if(block.is_non_ordered_op(head_last,block_op_pairs_dict,block_non_ordered_op_pairs_dict)): curr_color = key_color elif(is_colon(head_last)): curr_color = value_color elif(head_last==sp): curr_color = value_color else: curr_color = list_ele_color colon_meeted = 0 color_sec[color_sec_seq] = (si,ei,curr_color) color_sec_seq = color_sec_seq + 1 si = cursor return(si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted) def do_open_var(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted): ei = cursor - 1 curr_color = default_color color_sec[color_sec_seq] = (si,ei,curr_color) color_sec_seq = color_sec_seq + 1 si = cursor return(si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted) def do_open_var_bytes(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted): byte_meeted = 1 ei = cursor - 1 curr_color = default_color color_sec[color_sec_seq] = (si,ei,curr_color) color_sec_seq = color_sec_seq + 1 si = cursor return(si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted) def do_clear_byte_meeted(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted): byte_meeted = 0 return(si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted) def do_close_var(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted): ei = cursor - 1 if(colon_meeted): curr_color = value_color else: if(block.is_non_ordered_op(head_last,block_op_pairs_dict,block_non_ordered_op_pairs_dict)): curr_color = key_color elif(is_colon(head_last)): curr_color = value_color elif(head_last==sp): curr_color = value_color else: curr_color = list_ele_color colon_meeted = 0 color_sec[color_sec_seq] = (si,ei,curr_color) color_sec_seq = color_sec_seq + 1 si = cursor return(si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted) def do_colons(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted): colon_meeted = 1 return(si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted) def do_op(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted): ei = cursor - 1 curr_color = default_color if(ei >= si): color_sec[color_sec_seq] = (si,ei,curr_color) color_sec_seq = color_sec_seq + 1 else: pass si = cursor ei = cursor if(block.is_non_ordered_op(head_last,block_op_pairs_dict,block_non_ordered_op_pairs_dict)): curr_color = value_color elif(is_colon(head_last)): curr_color = value_color elif(head_last==sp): curr_color = value_color else: curr_color = list_ele_color color_sec[color_sec_seq] = (si,ei,curr_color) color_sec_seq = color_sec_seq + 1 si = cursor + 1 return(si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted) def do_close_var_colon(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted): colon_meeted = 1 return(do_close_var(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted)) #--------------------------------------------------------------------------------------- #### machine.add("INIT",regex_b,do_open_var_bytes,"BYTES") machine.add("INIT",regex_spaces,None,"INIT") machine.add("INIT",regex_colons,do_colons,"INIT") machine.add("INIT",regex_commas,None,"INIT") machine.add("INIT",regex_slash,do_open_var,"SLASHINIT") machine.add("INIT",regex_ops,do_op,"INIT") machine.add("INIT",regex_not_LqRqBSpColComSlOp,do_open_var,"OTHER") #### machine.add("BYTES",regex_b,do_clear_byte_meeted,"OTHER") machine.add("BYTES",regex_spaces,do_close_var,"BYTES") machine.add("BYTES",regex_ops,do_throw,"ERROR") machine.add("BYTES",regex_colons,do_close_var_colon,"INIT") machine.add("BYTES",regex_commas,do_close_var,"INIT") machine.add("BYTES",regex_slash,do_clear_byte_meeted,"SLASHBYTES") machine.add("BYTES",regex_not_LqRqBSpColComSlOp,do_clear_byte_meeted,"OTHER") #### #### machine.add("SLASHINIT",re.compile("."),None,"OTHER") #### machine.add("SLASHBYTES",re.compile("."),None,"OTHER") #### machine.add("OTHER",regex_b,None,"OTHER") machine.add("OTHER",regex_spaces,do_close_var,"OTHER") machine.add("OTHER",regex_ops,do_throw,"ERROR") machine.add("OTHER",regex_colons,do_close_var_colon,"INIT") machine.add("OTHER",regex_commas,do_close_var,"INIT") machine.add("OTHER",regex_slash,None,"SLASHOTHER") machine.add("OTHER",regex_not_LqRqBSpColComSlOp,None,"OTHER") #### machine.add("SLASHOTHER",re.compile("."),None,"OTHER") #### regex_lquote_array = fsm.creat_regexes_array(lquotes) regex_rquote_array = fsm.creat_regexes_array(rquotes) ### for i in range(0,lquotes.__len__()): ####INIT -lq_n-> LQ_n sn = ''.join(("LQ",'_',str(i))) machine.add("INIT",regex_lquote_array[i],do_open_quote,sn) for i in range(0,rquotes.__len__()): ####INIT -rq_n-> ERROR if(regex_rquote_array[i] == regex_lquote_array[i]): pass else: sn = ''.join(("LQ",'_',str(i))) machine.add("INIT",regex_rquote_array[i],do_throw,'ERROR') #### for i in range(0,lquotes.__len__()): ####BYTES -lq_n-> LQ_n sn = ''.join(("LQ",'_',str(i))) machine.add("BYTES",regex_lquote_array[i],do_open_quote,sn) for i in range(0,rquotes.__len__()): ####BYTES -rq_n-> ERROR if(rquotes[i] == lquotes[i]): pass else: sn = ''.join(("LQ",'_',str(i))) machine.add("BYTES",regex_rquote_array[i],do_throw,'ERROR') #### for i in range(0,lquotes.__len__()): ####OTHER -lq_n-> ERROR sn = ''.join(("LQ",'_',str(i))) machine.add("OTHER",regex_lquote_array[i],do_throw,'ERROR') for i in range(0,rquotes.__len__()): ####OTHER -rq_n-> ERROR if(rquotes[i] == lquotes[i]): pass else: sn = ''.join(("LQ",'_',str(i))) machine.add("OTHER",regex_rquote_array[i],do_throw,'ERROR') #### for i in range(0,lquotes.__len__()): ####LQ_n -lq_n-> ERROR sn = ''.join(("LQ",'_',str(i))) if(lquotes[i] == rquotes[i]): pass else: machine.add(sn,regex_lquote_array[i],do_throw,'ERROR') ####LQ_n -rq_n-> INIT machine.add(sn,regex_rquote_array[i],do_close_quote,'INIT') #####LQ_n -b-> LQ_n machine.add(sn,regex_b,None,sn) #####LQ_n -spaces-> LQ_n machine.add(sn,regex_spaces,None,sn) #####LQ_n -ops-> LQ_n machine.add(sn,regex_ops,do_throw,'ERROR') ####LQ_n -colons-> LQ_n machine.add(sn,regex_colons,do_throw,'ERROR') ####LQ_n -commas-> LQ_n machine.add(sn,regex_commas,do_throw,'ERROR') #####LQ_n -slash -> SLASHLQ_n slashlq = ''.join(("SLASHLQ",'_',str(i))) machine.add(sn,re.compile("\\\\"),None,slashlq) ####SLASHLQ_n -any-> LQ_n machine.add(slashlq,re.compile("."),None,sn) #####LQ_n -others-> LQ_n tmp_arr = ['b','\\\\'] + ops + colons + commas + spaces tmp_arr_rq = [rquotes[i]] tmp_arr_lq = [lquotes[i]] if(lquotes[i] == rquotes[i]): tmp_arr_rq = [] else: pass tmp_final_arr = tmp_arr + tmp_arr_rq + tmp_arr_lq #### tmp_regex = fsm.creat_regex_not_from_arr(tmp_final_arr) machine.add(sn,tmp_regex,None,sn) ##### #---------------------------------------------------------------- curr_state = "INIT" prev_symbol = '' for i in range(0,line.__len__()): cursor = i input_symbol = line[i] action,next_state,trigger_checker = machine.search(curr_state,input_symbol) #print('----------') #print(curr_state,trigger_checker,input_symbol,action,next_state) #print(line) #print(path) #print(i) if(action == do_throw): action(curr_state,trigger_checker,input_symbol,line,path,i) elif(action == None): pass else: si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted = action(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted) curr_state = next_state prev_symbol = input_symbol #-----Final handle------------------------------------------------------------ ####### if(curr_state == "INIT"): cursor = cursor + 1 if(block.is_op(input_symbol)): pass else: si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted = do_open_var(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted) curr_state = "INIT" ####### state_is_bytes = (curr_state == "BYTES") state_is_other = (curr_state == "OTHER") state_is_slashinit = (curr_state == "SLASHINIT") state_is_slashbytes = (curr_state == "SLASHBYTES") state_is_slashother = (curr_state == "SLASHOTHER") cond = (state_is_bytes|state_is_other|state_is_slashinit|state_is_slashbytes|state_is_slashother) ####### if(cond): cursor = cursor + 1 si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted = do_close_var(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted) curr_state = "INIT" ###### cond = ("SLASHLQ" in curr_state) if(cond): cursor = cursor + 1 si,ei,color_sec,color_sec_seq,colon_meeted,byte_meeted = do_open_quote(cursor,si,ei,color_sec,color_sec_seq,colon_meeted,prev_symbol,byte_meeted) curr_state = "INIT" return(color_sec)
def format_j_str(j_str, block_op_pairs_dict=block.get_block_op_pairs('{}[]()'), **kwargs): if ('spaces' in kwargs): spaces = kwargs['spaces'] else: spaces = [' ', '\t'] if ('colons' in kwargs): colons = kwargs['colons'] else: colons = [':'] if ('commas' in kwargs): commas = kwargs['commas'] else: commas = [','] if ('line_sps' in kwargs): line_sps = kwargs['line_sps'] else: line_sps = ['\r', '\n'] if ('quotes' in kwargs): quotes = kwargs['quotes'] else: quotes = ['"', "'"] # ---------------------------------------------------------------------------------- # __str__ will make some difference : eval will replace \\xXX wil \xXX # >>> js1 = "{'\x01': '\x02'}" # >>> js2 = "{'\\x01': '\\x02'}" # >>> # >>> j1 = eval(js1) # >>> j1 # {'\x01': '\x02'} # >>> j2 = eval(js2) # >>> j2 # {'\x01': '\x02'} # >>> j1 == j2 # True # >>> js1 == js2 # False # >>> js3 = j1.__str__() # >>> js1 == js3 # False # >>> js2 == js3 # True # >>> js3 # "{'\\x01': '\\x02'}" # >>> # format step 1: remove functinal-spaces(spaces not in quote) and functional-line_sp regex_remove_spaces = get_rm_regexp(spaces) j_str = regex_remove_spaces.sub("", j_str) regex_remove_line_sps = get_rm_regexp(line_sps) j_str = regex_remove_line_sps.sub("", j_str) # format step 2: replace functional-colons with "<colon> ",replace functional-sps with "<sp> \n" colon_and_sps = copy.copy(colons) colon_and_sps.extend(commas) insert_space_regexp = get_insert_space_regexp(colon_and_sps) j_str = re.sub(insert_space_regexp, r'\g<0> ', j_str) # format step 3: seperate each elements in one line j_str = j_str.replace(", ", ", \n") # format step 4: seerate recursive element in one new line for i in range(1, block_op_pairs_dict.__len__() + 1): j_str = j_str.replace(block_op_pairs_dict[i][0], ''.join( ("\n", block_op_pairs_dict[i][0], "\n"))) j_str = j_str.replace(block_op_pairs_dict[i][1], ''.join( ("\n", block_op_pairs_dict[i][1], "\n"))) j_str = j_str.replace("\n\n", "\n") # format step 5: move empty to one line # such as {} [] () for i in range(1, block_op_pairs_dict.__len__() + 1): j_str = j_str.replace( ''.join( (block_op_pairs_dict[i][0], '\n', block_op_pairs_dict[i][1])), ''.join((block_op_pairs_dict[i][0], block_op_pairs_dict[i][1]))) # format step 6: j_str = j_str.replace("\n,", ",") j_str = j_str.strip("\n") j_str = j_str.replace("\n\n", "\n") return (j_str)