def dcds1_get_children(d, ppl):
curr = eded._getitem_via_pathlist(d, ppl)
plsuffix = None
if (curr['content'] != None):
rchildren = elel.array_map(curr['content'], dcds1_norecur)
value_map_func_args = [ppl, 'content']
plsuffix = 'content'
elif (curr['arguments'] != None):
rchildren = elel.array_map(curr['arguments'], dcds1_norecur)
value_map_func_args = [ppl, 'arguments']
plsuffix = 'arguments'
else:
rchildren = []
value_map_func_args = [ppl]
def index_map_func(index):
return (index)
def value_map_func(index, ele, ppl, plsuffix):
pl = copy.deepcopy(ppl)
pl.append(plsuffix)
pl.append(index)
return ({"data": ele, "pl": pl})
children = elel.array_dualmap(rchildren,
index_map_func=index_map_func,
value_map_func=value_map_func,
value_map_func_args=value_map_func_args)
return ((children, rchildren, plsuffix))
def get_status(ckstr,url=URLS['status'],coding='gb2312',**kwargs):
if('ic' in kwargs):
ic = kwargs['ic']
else:
ic = get_page(ckstr,url)
d = get_raw_script_dict(ic,coding=coding)
spd = status_para_l2d(d['statusPara'])
wpd = wlan_para_l2d(d['wlanPara'])
d['statusPara'] = spd
d['wlanPara'] = wpd
d['wanParas'] = copy.deepcopy(d['wanPara'])
del d['wanPara']
####
row = d['statusPara']['row']
col = d['statusPara']['col']
wanParas= get_wan_para_list(d['wanParas'],col,row)
d['wanParas'] = elel.array_map(wanParas,wan_para_l2d,col,row)
####
statistList = copy.deepcopy(d['statistList'])
del d['statistList']
statistLists = get_statist_list(statistList,col)
d['statistLists'] = elel.array_map(statistLists,statist_l2d)
###########
d['lanPara'] = lan_para_l2d(d['lanPara'])
return(d)
def __setitem__(self,*args,**kwargs):
if(isinstance(args[0],tuple)):
#very special in __setitem__
value = args[-1]
value = str(value)
args = list(args[0])
key = args[0]
key = str(key)
whiches = elel.array_map(args[1:],int)
rslt = self._tlist.tl
for which in whiches:
rslt = tltl.set_which(rslt,key,value,which=which)
else:
#very special in __setitem__
key = args[0]
key = str(key)
value = args[-1]
value = str(value)
rslt = tltl.set_which(self._tlist.tl,key,value,which='all')
tl = self._tlist.tl
if(tltl._includes(tl,key=key)):
pass
else:
tl.append((key,value))
head_update(self,tl)
if(rslt.__len__() == 1):
return(rslt[0])
else:
return(rslt)
def encd_arguments(args):
'''
args = [
{
'content': None,
'name': None,
'value': -50.0,
'arguments': None,
'unit': None,
'type': 'percentage'
},
{
'content': None,
'name': None,
'value': ',',
'arguments': None,
'unit': None,
'type': 'literal'
},
{
'content': None,
'name': None,
'value': -50.0,
'arguments': None,
'unit': None,
'type': 'percentage'
},
],
encd_arguments(args)
'''
args = elel.filter(args, lambda ele: (ele['type'] != 'whitespace'))
args = elel.array_map(args, encd_one)
s = '(' + elel.join(args, '') + ')'
return (s)
def do_actions():
arr = sys.argv[1:]
if(arr[0] == '-help'):
s = '''
#read from params,-login must be the first
python3 mw316r.py -login -ip "192.168.1.1" -pw "lidapeng"
#read from config.cfg
python3 mw316r.py -login
python3 mw316r.py -status
python3 mw316r.py -status wan
python3 mw316r.py -status lan
python3 mw316r.py -status wlan
python3 mw316r.py -status general
python3 mw316r.py -status wan_stats
python3 mw316r.py -status wlan wan lan
'''
print(s)
elif(arr[0] == '-login'):
ckstr = login()
nvft.write_to_file(fn="ckstr.record",op="w+",content=ckstr)
elif(arr[0] == '-status'):
ckstr = load_ckstr()
params = arr[1:]
lngth = params.__len__()
if(lngth == 0):
d = get_status(ckstr)
pobj(d)
else:
params = elel.array_map(params,lambda ele:ACTIONS['status'][ele])
d = get_status(ckstr)
for key in params:
pobj(d[key])
elif(arr[0] == '-connect'):
def setcktl2ckstr(cls, setcktl, **kwargs):
'''
'''
dst_url = kwargs['url']
ckpl = elel.array_map(setcktl,
lambda setck: Cookie(setck).ckpair(url=dst_url))
ckstr = drone.list2ckstr(ckpl)
return (ckstr)
def wan_type_info_l2d(wantypeinfo):
count = int(wantypeinfo[0])
arr = wantypeinfo[1:]
arr = elel.divide(arr,2)
arr = arr[:count]
tl = elel.array_map(arr,tuple)
d = tltl.tlist2dict(tl)
return(d)
def serialize_array(arr):
arr = elel.array_map(arr, lambda ele: ele.serialize())
s = elel.join(arr, "")
s = s.replace('\t', "")
s = s.replace('\r', "")
s = s.replace('\n', "")
s = s.strip('\x20')
s = eses.replace(s, re.compile("[\x20]+"), "\x20")
return (s)
def sort_ckl(ckl, **kwargs):
'''
Cookies with longer paths are listed before cookies with shorter paths.
Among cookies that have equal-length path fields, cookies with earlier creation-times are
listed before cookies with later creation-times
'''
def add_plen(ele):
if (ele['Path'] == None):
ele['plen'] = 0
else:
ele['plen'] = ele['Path'].__len__()
def del_plen(ele):
del ele['plen']
ckl = elel.array_map(ckl, add_plen)
ckl = elel.sortDictList(ckl, ['plen', 'creation-time'])
ckl = elel.array_map(ckl, del_plen)
return (ckl)
def get_raw_script_dict(ic,coding='gb2312'):
rslt = nvbody.show_resp_body(ic,'script',coding=coding,only_print=False)
arr = xlt.ltdict_to_list(rslt)
arr = elel.array_map(arr,lambda ele:ele['result'])
arr = elel.cond_select_all(arr,cond_func=lambda ele:(ele!= None))
arr = elel.cond_select_all(arr,cond_func=lambda ele:("new Array" in ele))
arr = elel.array_map(arr,lambda ele:ele.replace('\n','').replace('\r','').replace('\t',''))
arr = elel.array_map(arr,lambda ele:ele.replace('var','').replace('new Array','').replace('(',"").replace(")","").replace(";",""))
arr.pop(-1)
arr = elel.array_map(arr,lambda ele:ele.split("="))
d = {}
for each in arr:
k = each[0].strip("\x20")
v = each[1].strip("\x20")
v = convert_token_in_quote(v)
v = v.split(",")
v = elel.array_map(v,html.unescape)
d[k] = v
return(d)
def type_q_sort_by_q(darr):
darr1 = elel.cond_select_values_all(darr,
cond_func=lambda ele:
(ele['q'] == None))
darr2 = elel.cond_select_values_all(darr,
cond_func=lambda ele:
(ele['q'] != None))
ndarr1 = elel.sortDictList(darr1, cond_keys=['q', 'type'], reverse=True)
idarr2 = elel.array_map(darr2, type_q_floatize)
ndarr2 = elel.sortDictList(darr2, cond_keys=['q', 'type'], reverse=True)
ndarr = elel.concat(ndarr1, ndarr2)
return (ndarr)
def rm_q(self, cond_func):
indexes = elel.cond_select_indexes_all(self.darr,
cond_func=lambda ele:
(ele['q'] == None))
idarr = elel.array_map(self.darr, language_locale_q_floatize)
orig_indexes = elel.cond_select_indexes_all(idarr, cond_func=cond_func)
idarr = elel.cond_select_values_all(idarr, cond_func=cond_func)
for index in indexes:
curr_index = orig_indexes.index(index)
idarr[curr_index]['q'] = None
self.darr = idarr
self.sarr = language_locale_q_darr2sarr(self.darr)
pobj(self.sarr)
def encd_square_blk(d, for_display=False):
'''
#for beautifier
#[ \x01
#] \x02
d = {
'content':
[
{
'content': None,
'name': None,
'type': 'ident',
'arguments': None,
'unit': None,
'value': 'title'
},
{
'content': None,
'name': None,
'type': 'literal',
'arguments': None,
'unit': None,
'value': '~='
},
{
'content': None,
'name': None,
'type': 'ident',
'arguments': None,
'unit': None,
'value': 'hello'
}
],
'name': None,
'type': '[] block',
'arguments': None,
'unit': None,
'value': None
}
encd_square_blk(d)
'''
c = cntnt_fmt_norecur(d['content'])
arr = elel.array_map(c, encd_one)
s = elel.join(arr, "")
if (for_display):
s = '\x01' + s + '\x02'
else:
s = '[' + s + ']'
return (s)
def __delitem__(self,*args,**kwargs):
if(isinstance(args[0],tuple)):
#very special in __delitem__
args = list(args[0])
key = args[0]
key = str(key)
whiches = elel.array_map(args[1:],int)
lngth = self._tlist.tl.__len__()
tltl._pop_seqs(self._tlist.tl,set(whiches),key=key)
else:
#very special in __delitem__
key = args[0]
key = str(key)
tltl._pop_all(self._tlist.tl,key=key)
tl = self._tlist.tl
update_after_remove(self,tl,key)
head_update(self,tl)
def cbs_fmt(cbs, **kwargs):
'''
cbs = 'float:none;display:block;'
cbs = 'float:none;display:block'
cbs = 'font-family: "Droid Sans", arial, sans-serif; font-weight: bold; font-size: 14px;'
'''
if ('sp' in kwargs):
sp = kwargs['sp']
else:
sp = ';'
cbs = convert_token_in_quote(cbs, colons=[";"])
cbs = cbs.replace(";", "")
cbs = html.unescape(cbs)
cbs = cbs.strip(sp)
arr = cbs.split(sp)
arr = elel.array_map(arr, lambda ele: (ele + sp))
return (arr)
def encd_paren_blk(d):
'''
d = {
'content':
[
{
'content': None,
'name': None,
'value': 'min-width',
'arguments': None,
'unit': None,
'type': 'ident'
},
{
'content': None,
'name': None,
'value': ':',
'arguments': None,
'unit': None,
'type': 'literal'
},
{
'content': None,
'name': None,
'value': 900.0,
'arguments': None,
'unit': 'px',
'type': 'dimension'
}
],
'name': None,
'value': None,
'arguments': None,
'unit': None,
'type': '() block'
}
'''
c = cntnt_fmt_norecur(d['content'])
paren = elel.array_map(c, encd_one)
s = elel.join(paren, "")
s = '(' + s + ')'
#d = scil2dict(paren)
#t = (d,)
return (s)
def __getitem__(self,*args,**kwargs):
if(isinstance(args[0],tuple)):
#very special in __getitem__
args = list(args[0])
key = args[0]
key = str(key)
whiches = elel.array_map(args[1:],int)
rslt = tltl.get_value(self._tlist.tl,key,whiches=whiches)
else:
#very special in __getitem__
key = args[0]
key = str(key)
rslt = tltl.get_value(self._tlist.tl,key)
if(rslt.__len__() == 1):
return(rslt[0])
elif(rslt.__len__() == 0):
raise(KeyError)
else:
return(rslt)
def cntnt_rm_whitespace(content):
content = cntnt_fmt_norecur(content)
rslt = elel.init(content.__len__())
unhandled = cntnt_init_unhandled(content)
while (unhandled.__len__() > 0):
next_unhandled = []
for i in range(0, unhandled.__len__()):
ele = unhandled[i]
data = ele['data']
ppl = ele['pl']
cond = cntnt_is_leaf(data)
if (cond):
rslt = elel.setitem_via_pathlist(rslt, data, ppl)
else:
children = cntnt_get_children(data, ppl)
rchildren = elel.array_map(children,
lambda child: child['data'])
dummy = copy.deepcopy(data)
dummy['content'] = rchildren
rslt = elel.setitem_via_pathlist(rslt, dummy, ppl)
next_unhandled = elel.concat(next_unhandled, children)
unhandled = next_unhandled
return (rslt)
def split_words_repo():
ARRS[0] = nvft.read_json(fn='granada_es.all.arr', op='r+')
ARRS[1] = elel.array_map(ARRS[0], lambda ele: str.strip(ele, " "))
ARRS[2] = elel.cond_select_values_all(
ARRS[1], cond_func=lambda ele: not (" " in ele))
ARRS[3] = elel.cond_select_values_all(
ARRS[2], cond_func=lambda ele: not ("!" in ele))
ARRS[4] = elel.cond_select_values_all(
ARRS[3], cond_func=lambda ele: not (R_EXCM in ele))
ARRS[5] = elel.cond_select_values_all(
ARRS[4], cond_func=lambda ele: not ("?" in ele))
ARRS[6] = elel.cond_select_values_all(
ARRS[5], cond_func=lambda ele: not (R_QM in ele))
ARRS[7] = elel.cond_select_values_all(
ARRS[6], cond_func=lambda ele: not ("-" in ele))
ARRS[8] = elel.cond_select_values_all(
ARRS[7], cond_func=lambda ele: not ("," in ele))
ARRS[9] = elel.cond_select_values_all(
ARRS[8], cond_func=lambda ele: not ("_" in ele))
ARRS[10] = elel.cond_select_values_all(ARRS[9], cond_func=no_num_cond_func)
nvft.write_json(fn='granada_es.all.single.nomark.arr',
json=ARRS[10],
op='w+')
def head_update(self,tl):
d = head_tl2d(tl)
super(Head,self).__setattr__('_dict',d)
objt = tltl.Tlist(tl)
super(Head,self).__setattr__('_tlist',objt)
kl,vl = objt.kvlists()
methods = elel.array_map(kl,underscorize_head_name)
refd_o2u = eded.kvlist2d(kl,methods)
super(Head,self).__setattr__('_orig2us_ref',refd_o2u)
refd_u2o = eded.dict_mirror(refd_o2u)
super(Head,self).__setattr__('_us2orig_ref',refd_u2o)
lngth = methods.__len__()
super(Head,self).__setattr__('count',lngth)
for i in range(0,lngth):
method = methods[i]
values = tltl.get_value(self._tlist.tl,kl[i])
if(values.__len__()==1):
#setattr(self,method,values[0])
# self.__dict__[method] = values[0]
super(Head,self).__setattr__(method,values[0])
else:
#setattr(self,method,values)
# self.__dict__[method] = values
super(Head,self).__setattr__(method,values)
def beautify_cssfile(src_file, dst_file):
css = CSS(fn=src_file)
rs = elel.array_map(css.rules, lambda ele: Rule(ele).css)
arr = elel.array_map(rs, trim_func)
s = elel.join(arr, '\n')
write_file(dst_file, s)
def ckpl(self, **kwargs):
dst_url = kwargs['url']
ckpl = elel.array_map(setcktl,
lambda setck: Cookie(setck).ckpair(url=dst_url))
return (ckpl)
def head_tl2sarr(tl,**kwargs):
sarr = elel.array_map(tl,lambda ele:(ele[0]+': '+ele[1]))
return(sarr)
def language_locale_q_sarr2darr(sarr, sp='-', **kwargs):
darr = elel.array_map(sarr, language_locale_q_ele_s2d, sp)
return (darr)
def language_locale_q_darr2sarr(darr, sp='-', **kwargs):
sarr = elel.array_map(darr, language_locale_q_ele_d2s, sp)
return (sarr)
def prelude_cil2str(cil):
'''
'''
if (cil.__len__() == 0):
return ("")
else:
pass
####
def cond_func(s):
s = eses.replace(s, re.compile("[\x20]+"), "\x20")
return (s)
####
cil = elel.array_map(cil, cond_func)
####
lngth = cil.__len__()
####
prev = cil[0]
ncil = [prev]
####
i = 1
while (i < (lngth - 1)):
prev = cil[i - 1]
curr = cil[i]
nxt = cil[i + 1]
########PREV########
if (curr in SELATTABOTHS):
if (prev == "\x20"):
ncil.pop(-1)
else:
pass
else:
pass
########NEXT########
if (curr in SELATTANEXTS):
if (nxt == "\x20"):
#no need whitespace after "."
i = i + 1
ncil.append(curr)
else:
ncil.append(curr)
elif (curr in SELATTABOTHS):
if (nxt == "\x20"):
#no need whitespace after
i = i + 1
ncil.append(curr)
else:
ncil.append(curr)
else:
ncil.append(curr)
i = i + 1
####
if (lngth > 1):
prev = cil[lngth - 2]
curr = cil[lngth - 1]
if (curr in SELATTABOTHS):
if (prev == "\x20"):
ncil.pop(-1)
else:
pass
else:
pass
ncil.append(curr)
#########
if (ncil[0] in SELATTANEXTS):
if (ncil[1] == "\x20"):
ncil.pop(1)
else:
pass
else:
pass
else:
pass
####
####
s = elel.join(ncil, "")
s = eses.replace(s, re.compile("[\x20]+"), "\x20")
return (s.strip('\x20'))
def type_q_darr2sarr(darr, **kwargs):
sarr = elel.array_map(darr, type_q_ele_d2s)
return (sarr)
def at_all(self, sel, mode="loose"):
rs = slct_at_all(self.rules, sel, mode)
rs = elel.array_map(rs, lambda r: Rule(r))
return (rs)
def beautify(input):
css = CSS(input=input)
rs = elel.array_map(css.rules, lambda ele: Rule(ele).css)
arr = elel.array_map(rs, trim_func)
s = elel.join(arr, '\n')
return (s)
def ckl2ckstr(ckl, dst_url):
ckpl = elel.array_map(ckl, slctckpair, dst_url)
ckstr = drone.pl2ckstr(ckpl)
return (ckstr)
